vtkSMPropertyHelper.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Kitware Inc.
// SPDX-FileCopyrightText: Copyright (c) 2007, Sandia Corporation
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkSMPropertyHelper_h
#define vtkSMPropertyHelper_h
 
#include "vtkRemotingServerManagerModule.h" //needed for exports
#include "vtkVariant.h"                     // for vtkVariant
 
#include <vector> // for std::vector
 
#ifdef INT
#undef INT
#endif
#ifdef DOUBLE
#undef DOUBLE
#endif
#ifdef NONE
#undef NONE
#endif
 
class vtkSMDoubleVectorProperty;
class vtkSMIdTypeVectorProperty;
class vtkSMInputProperty;
class vtkSMIntVectorProperty;
class vtkSMOutputPort;
class vtkSMProperty;
class vtkSMProxy;
class vtkSMProxyProperty;
class vtkSMStringVectorProperty;
class vtkSMVectorProperty;
 
class VTKREMOTINGSERVERMANAGER_EXPORT vtkSMPropertyHelper
{
public:
 
  vtkSMPropertyHelper(vtkSMProxy* proxy, const char* name, bool quiet = false);
  vtkSMPropertyHelper(vtkSMProperty* property, bool quiet = false);
  ~vtkSMPropertyHelper();
 
  void UpdateValueFromServer();
 
  void SetNumberOfElements(unsigned int elems);
 
  unsigned int GetNumberOfElements() const;
 
  void RemoveAllValues() { this->SetNumberOfElements(0); }
 
  vtkVariant GetAsVariant(unsigned int index) const;
 
  template <class T>
  std::vector<T> GetArray() const;
 
  template <class T>
  T GetAs(unsigned int index = 0) const;
 
 
  void Set(int value) { this->Set(0, value); }
  void Set(unsigned int index, int value);
  void Set(const int* values, unsigned int count);
  void Append(const int* values, unsigned int count);
  int GetAsInt(unsigned int index = 0) const;
  unsigned int Get(int* values, unsigned int count = 1) const;
  std::vector<int> GetIntArray() const;
 
 
  void Set(double value) { this->Set(0, value); }
  void Set(unsigned int index, double value);
  void Set(const double* values, unsigned int count);
  void Append(const double* values, unsigned int count);
  double GetAsDouble(unsigned int index = 0) const;
  unsigned int Get(double* values, unsigned int count = 1) const;
  std::vector<double> GetDoubleArray() const;
 
#if VTK_SIZEOF_ID_TYPE != VTK_SIZEOF_INT
 
  void Set(vtkIdType value) { this->Set(0, value); }
  void Set(unsigned int index, vtkIdType value);
  void Set(const vtkIdType* values, unsigned int count);
  void Append(const vtkIdType* values, unsigned int count);
  unsigned int Get(vtkIdType* values, unsigned int count = 1) const;
#endif
  vtkIdType GetAsIdType(unsigned int index = 0) const;
  std::vector<vtkIdType> GetIdTypeArray() const;
 
 
  void Set(const char* value) { this->Set(0, value); }
  void Set(unsigned int index, const char* value);
  const char* GetAsString(unsigned int index = 0) const;
 
 
  void Set(vtkSMProxy* value, unsigned int outputport = 0) { this->Set(0, value, outputport); }
  void Set(unsigned int index, vtkSMProxy* value, unsigned int outputport = 0);
  void Set(vtkSMProxy** value, unsigned int count, unsigned int* outputports = nullptr);
  void Add(vtkSMProxy* value, unsigned int outputport = 0);
  void Remove(vtkSMProxy* value);
  vtkSMProxy* GetAsProxy(unsigned int index = 0) const;
  unsigned int GetOutputPort(unsigned int index = 0) const;
  vtkSMOutputPort* GetAsOutputPort(unsigned int index = 0) const;
 
 
  void SetStatus(const char* key, int value);
  int GetStatus(const char* key, int default_value = 0) const;
 
 
  void SetStatus(const char* key, double* values, int num_values);
  bool GetStatus(const char* key, double* values, int num_values) const;
 
 
  void SetStatus(int key, int* values, int num_values);
  bool GetStatus(int key, int* values, int num_values) const;
 
 
  void SetStatus(const char* key, const char* value);
  const char* GetStatus(const char* key, const char* default_value) const;
 
  void RemoveStatus(const char* key);
 
 
  void SetStatus(int key, int value);
  int GetStatus(int key, int default_value = 0) const;
 
 
  void SetInputArrayToProcess(int fieldAssociation, const char* arrayName);
  int GetInputArrayAssociation() const;
  const char* GetInputArrayNameToProcess() const;
 
  void SetUseUnchecked(bool val) { this->UseUnchecked = val; }
  bool GetUseUnchecked() const { return this->UseUnchecked; }
 
  bool Copy(const vtkSMPropertyHelper& source);
 
  vtkSMPropertyHelper& Modified();
 
protected:
  void setUseUnchecked(bool useUnchecked) { this->UseUnchecked = useUnchecked; }
 
private:
  vtkSMPropertyHelper(const vtkSMPropertyHelper&) = delete;
  void operator=(const vtkSMPropertyHelper&) = delete;
  void Initialize(vtkSMProperty* property);
 
  template <typename T>
  T GetProperty(unsigned int index) const;
  template <typename T>
  std::vector<T> GetPropertyArray() const;
  template <typename T>
  unsigned int GetPropertyArray(T* values, unsigned int count = 1) const;
  template <typename T>
  void SetProperty(unsigned int index, T value);
  template <typename T>
  void SetPropertyArray(const T* values, unsigned int count);
  void SetPropertyArrayIdType(const vtkIdType* values, unsigned int count);
  template <typename T>
  void AppendPropertyArray(const T* values, unsigned int count);
  template <typename T>
  bool CopyInternal(const vtkSMPropertyHelper& source);
 
  enum PType
  {
    INT,
    DOUBLE,
    IDTYPE,
    STRING,
    PROXY,
    INPUT,
    NONE
  };
 
  bool Quiet;
  bool UseUnchecked;
  vtkSMProxy* Proxy;
  PType Type;
 
  union {
    vtkSMProperty* Property;
    vtkSMVectorProperty* VectorProperty;
    vtkSMIntVectorProperty* IntVectorProperty;
    vtkSMDoubleVectorProperty* DoubleVectorProperty;
    vtkSMIdTypeVectorProperty* IdTypeVectorProperty;
    vtkSMStringVectorProperty* StringVectorProperty;
    vtkSMProxyProperty* ProxyProperty;
    vtkSMInputProperty* InputProperty;
  };
};
 
template <>
inline std::vector<int> vtkSMPropertyHelper::GetArray() const
{
  return this->GetIntArray();
}
 
template <>
inline std::vector<double> vtkSMPropertyHelper::GetArray() const
{
  return this->GetDoubleArray();
}
 
#if VTK_SIZEOF_ID_TYPE != VTK_SIZEOF_INT
template <>
inline std::vector<vtkIdType> vtkSMPropertyHelper::GetArray() const
{
  return this->GetIdTypeArray();
}
#endif
 
template <>
inline int vtkSMPropertyHelper::GetAs(unsigned int index) const
{
  return this->GetAsInt(index);
}
 
template <>
inline double vtkSMPropertyHelper::GetAs(unsigned int index) const
{
  return this->GetAsDouble(index);
}
 
#if VTK_SIZEOF_ID_TYPE != VTK_SIZEOF_INT
template <>
inline vtkIdType vtkSMPropertyHelper::GetAs(unsigned int index) const
{
  return this->GetAsIdType(index);
}
#endif
 
#endif
 
// VTK-HeaderTest-Exclude: vtkSMPropertyHelper.h