vtkCellMetadata.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 vtkCellMetadata_h
#define vtkCellMetadata_h

#include "vtkCellGridResponders.h"    // For ivar.
#include "vtkCommonDataModelModule.h" // for export macro
#include "vtkInherits.h"              // for vtk::Inherits<>()
#include "vtkNew.h"                   // for queries
#include "vtkObject.h"
#include "vtkSmartPointer.h" // for constructor return values
#include "vtkStringToken.h"  // for vtkStringToken::Hash
#include "vtkTypeName.h"     // for vtk::TypeName<>()

#include <token/Singletons.h> // Increment Schwarz counter for initialization.

#include <functional>
#include <set>
#include <unordered_map>
#include <unordered_set>

VTK_ABI_NAMESPACE_BEGIN
class vtkCellGrid;
class vtkCellGridQuery;
class vtkDataSetAttributes;
class vtkCellAttribute;

class VTKCOMMONDATAMODEL_EXPORT vtkCellMetadata : public vtkObject
{
public:
  using CellTypeId = vtkStringToken::Hash;
  using DOFType = vtkStringToken;
  using MetadataConstructor = std::function<vtkSmartPointer<vtkCellMetadata>(vtkCellGrid*)>;
  using ConstructorMap = std::unordered_map<vtkStringToken, MetadataConstructor>;

  vtkTypeMacro(vtkCellMetadata, vtkObject);
  vtkInheritanceHierarchyBaseMacro(vtkCellMetadata);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  template <typename Subclass>
  static bool RegisterType()
  {
    vtkStringToken name = vtk::TypeName<Subclass>();
    auto status = vtkCellMetadata::Constructors().insert(std::make_pair(name,
      [](vtkCellGrid* grid)
      {
        auto result = vtkSmartPointer<Subclass>::New();
        if (result)
        {
          result->SetCellGrid(grid);
        }
        return result;
      }));
    return status.second; // true if insertion occurred.
  }

  template <typename Subclass>
  static vtkSmartPointer<Subclass> NewInstance(vtkCellGrid* grid = nullptr)
  {
    vtkStringToken name = vtk::TypeName<Subclass>();
    auto metadata = vtkCellMetadata::NewInstance(name, grid);
    vtkSmartPointer<Subclass> result(Subclass::SafeDownCast(metadata));
    return result;
  }

  static vtkSmartPointer<vtkCellMetadata> NewInstance(
    vtkStringToken className, vtkCellGrid* grid = nullptr);

  static std::unordered_set<vtkStringToken> CellTypes();

  CellTypeId Hash() { return vtkStringToken(this->GetClassName()).GetId(); }

  virtual bool SetCellGrid(vtkCellGrid* parent);

  vtkGetObjectMacro(CellGrid, vtkCellGrid);

  virtual vtkIdType GetNumberOfCells() { return 0; }

  bool Query(vtkCellGridQuery* query);

  virtual void ShallowCopy(vtkCellMetadata* vtkNotUsed(other)) {}
  virtual void DeepCopy(vtkCellMetadata* vtkNotUsed(other)) {}

  static vtkCellGridResponders* GetResponders();

  static void ClearResponders();

  vtkCellGridResponders* GetCaches();

protected:
  vtkCellMetadata() = default;
  ~vtkCellMetadata() override;

  vtkCellGrid* CellGrid{ nullptr };

  static ConstructorMap& Constructors();

private:
  vtkCellMetadata(const vtkCellMetadata&) = delete;
  void operator=(const vtkCellMetadata&) = delete;
};

VTK_ABI_NAMESPACE_END
#endif