vtkInherits.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 vtkInherits_h
#define vtkInherits_h
 
#include "vtkTypeName.h"
 
#include <string>
 
#define vtkInheritanceHierarchyBodyMacro(thisClass)                                                \
  {                                                                                                \
    std::vector<vtkStringToken> result;                                                            \
    vtk::Inherits<thisClass>(result);                                                              \
    return result;                                                                                 \
  }
 
 
#define vtkInheritanceHierarchyBaseMacro(thisClass)                                                \
  virtual std::vector<vtkStringToken> InheritanceHierarchy()                                       \
    const vtkInheritanceHierarchyBodyMacro(thisClass)
 
#define vtkInheritanceHierarchyOverrideMacro(thisClass)                                            \
  std::vector<vtkStringToken> InheritanceHierarchy()                                               \
    const override vtkInheritanceHierarchyBodyMacro(thisClass)
 
namespace vtk
{
namespace detail
{
VTK_ABI_NAMESPACE_BEGIN
 
// Used by Inherits with ParentClasses to produce a list of inherited type names.
template <typename Container, typename StopAtType = void>
struct AddNames
{
  AddNames(Container& c)
    : m_container(c)
  {
  }
 
  template <typename T>
  bool operator()()
  {
    if (!std::is_same<StopAtType, T>::value)
    {
      std::string typeName = vtk::TypeName<T>();
      m_container.insert(m_container.end(), typeName);
      return true;
    }
    return false;
  }
  Container& m_container;
};
 
VTK_ABI_NAMESPACE_END
} // namespace detail
 
VTK_ABI_NAMESPACE_BEGIN
 
template <typename VTKObjectType>
class HasSuperclass
{
  class No
  {
  };
  class Yes
  {
    No no[2];
  };
 
  template <typename C>
  static Yes Test(typename C::Superclass*);
  template <typename C>
  static No Test(...);
 
public:
  enum
  {
    value = sizeof(Test<VTKObjectType>(nullptr)) == sizeof(Yes)
  };
};
 
 
template <typename VTKObjectType, bool IsDerived = HasSuperclass<VTKObjectType>::value>
struct ParentClasses;
 
template <typename VTKObjectType>
struct ParentClasses<VTKObjectType, false>
{
  template <typename Functor>
  inline static void enumerate(Functor& ff)
  {
    ff.template operator()<VTKObjectType>();
  }
};
 
template <typename VTKObjectType>
struct ParentClasses<VTKObjectType, true>
{
  // This variant handles Functors with a void return type.
  template <typename Functor>
  inline static typename std::enable_if<
    std::is_same<decltype(std::declval<Functor>().template operator()<vtkObject>()), void>::value,
    void>::type enumerate(Functor& ff)
  {
    ff.template operator()<VTKObjectType>();
    ParentClasses<typename VTKObjectType::Superclass>::enumerate(ff);
  }
 
  // This variant handles Functors with a bool return type.
  template <typename Functor>
  inline static typename std::enable_if<
    std::is_same<decltype(std::declval<Functor>().template operator()<vtkObject>()), bool>::value,
    void>::type enumerate(Functor& ff)
  {
    if (ff.template operator()<VTKObjectType>())
    {
      ParentClasses<typename VTKObjectType::Superclass>::enumerate(ff);
    }
  }
};
 
 
template <typename VTKObjectType, typename Container>
void Inherits(Container& container)
{
  detail::AddNames<Container> addNames(container);
  ParentClasses<VTKObjectType>::enumerate(addNames);
}
 
template <typename VTKObjectType, typename StopAtType, typename Container>
void Inherits(Container& container)
{
  detail::AddNames<Container, StopAtType> addNames(container);
  ParentClasses<VTKObjectType>::enumerate(addNames);
}
 
VTK_ABI_NAMESPACE_END
} // namespace vtk
 
#endif // vtkInherits_h