vtkDataObjectMeshCache.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 vtkDataObjectMeshCache_h
#define vtkDataObjectMeshCache_h
 
#include "vtkFiltersTemporalModule.h" // Export macro
 
#include "vtkAlgorithm.h" // for algorithm
#include "vtkObject.h"
#include "vtkSmartPointer.h" // for smart pointer
#include "vtkWeakPointer.h"  // for weak pointer
 
#include <set>    // for set
#include <string> // for string
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkDataObject;
class vtkDataSet;
class vtkCompositeDataSet;

class VTKFILTERSTEMPORAL_EXPORT vtkDataObjectMeshCache : public vtkObject
{
public:
  static vtkDataObjectMeshCache* New();
  vtkTypeMacro(vtkDataObjectMeshCache, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  struct Status
  {
    bool OriginalDataDefined = false;
    bool ConsumerDefined = false;
    bool CacheDefined = false;
    bool OriginalMeshUnmodified = false;
    bool ConsumerUnmodified = false;
    bool AttributesIdsExists = true;

    bool enabled()
    {
      return this->OriginalDataDefined && this->ConsumerDefined && this->CacheDefined &&
        this->ConsumerUnmodified && this->OriginalMeshUnmodified && this->AttributesIdsExists;
    }

    bool operator==(const Status& other) const
    {
      return other.OriginalDataDefined == this->OriginalDataDefined &&
        other.ConsumerDefined == this->ConsumerDefined &&
        other.CacheDefined == this->CacheDefined &&
        other.OriginalMeshUnmodified == this->OriginalMeshUnmodified &&
        other.ConsumerUnmodified == this->ConsumerUnmodified &&
        other.AttributesIdsExists == this->AttributesIdsExists;
    }

    bool operator!=(const Status& other) const { return !(*this == other); }

    void PrintSelf(ostream& os, vtkIndent indent);
  };


  vtkSetSmartPointerMacro(Consumer, vtkAlgorithm);

  void SetOriginalDataObject(vtkDataObject* original);


  void AddOriginalIds(int attribute, const std::string& name);

  void RemoveOriginalIds(int attribute);

  void ClearOriginalIds();

  void ForwardAttribute(int attribute);

  vtkSetMacro(PreserveAttributes, bool);
  vtkGetMacro(PreserveAttributes, bool);
  vtkBooleanMacro(PreserveAttributes, bool);

  static std::string GetTemporaryIdsName();

  static void CreateTemporaryOriginalIdsArrays(vtkDataObject* object);

  static void CleanupTemporaryOriginalIds(vtkDataObject* object);

  static vtkMTimeType GetDataObjectMeshMTime(vtkDataObject* object);

  Status GetStatus() const;

  void CopyCacheToDataObject(vtkDataObject* output);

  void UpdateCache(vtkDataObject* newObject);

  void InvalidateCache();

  bool IsSupportedData(vtkDataObject* dataobject) const;
 
protected:
  vtkDataObjectMeshCache() = default;
  ~vtkDataObjectMeshCache() override = default;
  void ForwardAttributes(vtkDataSet* input, vtkDataSet* cache, vtkDataSet* output, int attribute,
    const std::string& name);
  void ForwardAttributesToDataSet(vtkDataSet* input, vtkDataSet* cache, vtkDataSet* output);
  void ForwardAttributesToComposite(vtkCompositeDataSet* input, vtkCompositeDataSet* output);
 
private:
  vtkDataObjectMeshCache(const vtkDataObjectMeshCache&) = delete;
  void operator=(const vtkDataObjectMeshCache&) = delete;

  vtkDataObject* GetOriginalDataObject() const;

  vtkMTimeType GetOriginalMeshTime() const;

  vtkIdType GetNumberOfDataSets(vtkDataObject* dataobject) const;

  bool CacheHasRequestedIds() const;

  void ClearAttributes(vtkDataObject*);

  bool HasConsumerNoInputPort() const;
 
  vtkWeakPointer<vtkAlgorithm> Consumer;
  vtkSmartPointer<vtkDataObject> Cache;
  vtkWeakPointer<vtkDataSet> OriginalDataSet;
  vtkWeakPointer<vtkCompositeDataSet> OriginalCompositeDataSet;
  vtkMTimeType CachedOriginalMeshTime = 0;
  vtkMTimeType CachedConsumerTime = 0;
  std::map<int, std::string> OriginalIdsName;
  bool PreserveAttributes = false;
};
 
VTK_ABI_NAMESPACE_END
#endif