vtkCellGridResponders.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 vtkCellGridResponders_h
#define vtkCellGridResponders_h
 
#include "vtkCellAttributeCalculator.h" // For API.
#include "vtkCommonDataModelModule.h"   // For export macro
#include "vtkObject.h"
#include "vtkSmartPointer.h" // For return values
#include "vtkStringToken.h"  // For API.
#include "vtkTypeName.h"     // For RegisterQueryResponder.
 
#include <unordered_map>
#include <unordered_set>
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCellGridQuery;
class vtkCellGridResponderBase;
class vtkCellMetadata;
 
class VTKCOMMONDATAMODEL_EXPORT vtkCellGridResponders : public vtkObject
{
public:
  static vtkCellGridResponders* New();
 
  using TagSet = std::unordered_map<vtkStringToken, std::unordered_set<vtkStringToken>>;
 
  struct CalculatorForTagSet
  {
    TagSet MatchingTags;
    vtkSmartPointer<vtkCellAttributeCalculator> CalculatorPrototype;
 
    bool Matches(const TagSet& providedTags) const;
  };
 
  vtkTypeMacro(vtkCellGridResponders, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  template <typename CellType, typename QueryType, typename ResponderType>
  void RegisterQueryResponder(ResponderType* responder)
  {
    vtkStringToken queryTypeKey = vtk::TypeName<QueryType>();
    vtkStringToken cellTypeKey = vtk::TypeName<CellType>();
    this->Responders[queryTypeKey][cellTypeKey] = responder;
  }
 
  bool Query(vtkCellMetadata* cellType, vtkCellGridQuery* query);
 
  template <typename CellType, typename CalculatorType>
  bool RegisterCalculator(vtkStringToken tags, vtkCellAttributeCalculator* calculator)
  {
    if (!calculator)
    {
      vtkErrorMacro("Could not register null cell-attribute calculator.");
      return false;
    }
 
    vtkStringToken calculatorBaseKey = vtk::TypeName<CalculatorType>();
    vtkStringToken cellTypeKey = vtk::TypeName<CellType>();
    if (!dynamic_cast<CalculatorType*>(calculator))
    {
      vtkErrorMacro("Could not register cell-attribute calculator "
        << calculator->GetClassName() << " as it does not inherit " << calculatorBaseKey.Data()
        << ".");
      return false;
    }
 
    this->Calculators[calculatorBaseKey][cellTypeKey][tags] = calculator;
    return true;
  }
 
  template <typename CellType, typename CalculatorType>
  bool RegisterCalculator(vtkCellAttributeCalculator* calculator, const TagSet& tags)
  {
    using namespace vtk::literals;
    if (!calculator)
    {
      vtkErrorMacro("Could not register null cell-attribute calculator.");
      return false;
    }
 
    vtkStringToken calculatorBaseKey = vtk::TypeName<CalculatorType>();
    vtkStringToken cellTypeKey = vtk::TypeName<CellType>();
    if (!dynamic_cast<CalculatorType*>(calculator))
    {
      vtkErrorMacro("Could not register cell-attribute calculator "
        << calculator->GetClassName() << " as it does not inherit " << calculatorBaseKey.Data()
        << ".");
      return false;
    }
 
    TagSet tagsIncludingType = tags;
    tagsIncludingType["Type"_token] = { cellTypeKey };
    this->CalculatorRegistry[calculatorBaseKey].push_back(
      CalculatorForTagSet{ tagsIncludingType, calculator });
    return true;
  }
 
  vtkSmartPointer<vtkCellAttributeCalculator> AttributeCalculator(vtkStringToken calculatorType,
    vtkCellMetadata* cellType, vtkCellAttribute* attrib, const TagSet& tags) const;
 
  template <typename CalculatorType>
  vtkSmartPointer<CalculatorType> AttributeCalculator(
    vtkCellMetadata* cellType, vtkCellAttribute* cellAttribute) const
  {
    auto calculatorKey = vtk::TypeName<CalculatorType>();
    auto baseResult = this->AttributeCalculator(calculatorKey, cellType, cellAttribute);
    auto result = CalculatorType::SafeDownCast(baseResult);
    return result;
  }
 
  template <typename CalculatorType>
  vtkSmartPointer<CalculatorType> AttributeCalculator(
    vtkCellMetadata* cellType, vtkCellAttribute* attrib, const TagSet& tags) const
  {
    auto calculatorKey = vtk::TypeName<CalculatorType>();
    auto baseResult = this->AttributeCalculator(calculatorKey, cellType, attrib, tags);
    auto result = CalculatorType::SafeDownCast(baseResult);
    return result;
  }
 
  vtkSmartPointer<vtkObject> GetCacheData(std::size_t key);
 
  template <typename CacheType>
  vtkSmartPointer<CacheType> GetCacheDataAs(std::size_t key, bool createIfAbsent = false)
  {
    vtkSmartPointer<CacheType> castCache;
    auto rawCache = this->GetCacheData(key);
    if (!rawCache)
    {
      if (createIfAbsent)
      {
        castCache = vtkSmartPointer<CacheType>::New();
        this->Caches[key] = castCache;
      }
      return castCache;
    }
    castCache = dynamic_cast<CacheType*>(rawCache.GetPointer());
    return castCache;
  }
 
  bool SetCacheData(std::size_t key, vtkSmartPointer<vtkObject> value, bool overwrite = false);
 
protected:
  vtkCellGridResponders() = default;
  ~vtkCellGridResponders() override = default;
 
  std::unordered_map<vtkStringToken,
    std::unordered_map<vtkStringToken, vtkSmartPointer<vtkCellGridResponderBase>>>
    Responders;
 
  std::unordered_map<std::size_t, vtkSmartPointer<vtkObject>> Caches;
 
  std::unordered_map<vtkStringToken, std::vector<CalculatorForTagSet>> CalculatorRegistry;
 
  std::unordered_map<vtkStringToken,
    std::unordered_map<vtkStringToken,
      std::unordered_map<vtkStringToken, vtkSmartPointer<vtkCellAttributeCalculator>>>>
    Calculators;
 
private:
  vtkCellGridResponders(const vtkCellGridResponders&) = delete;
  void operator=(const vtkCellGridResponders&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif