#include <Standard.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Transient.hxx>
#include <Standard_OStream.hxx>
#include <typeinfo>
#include <typeindex>
#include <type_traits>

Data Structures
class	Standard_Type
	This class provides legacy interface (type descriptor) to run-time type information (RTTI) for OCCT classes inheriting from Standard_Transient. More...

Macros
#define	OCCT_CHECK_BASE_CLASS(Class, Base)

#define	STANDARD_TYPE(theType) theType::get_type_descriptor()
	Helper macro to get instance of a type descriptor for a class in a legacy way. More...

#define	DEFINE_STANDARD_RTTI_INLINE(Class, Base)
	Helper macro to be included in definition of the classes inheriting Standard_Transient to enable use of OCCT RTTI. More...

#define	DEFINE_STANDARD_RTTIEXT(Class, Base)
	Helper macro to be included in definition of the classes inheriting Standard_Transient to enable use of OCCT RTTI. More...

#define	IMPLEMENT_STANDARD_RTTIEXT(Class, Base)
	Defines implementation of type descriptor and DynamicType() function. More...

Functions
Standard_OStream &	operator<< (Standard_OStream &theStream, const Handle< Standard_Type > &theType)
	Operator printing type descriptor to stream. More...

Macro Definition Documentation

#define DEFINE_STANDARD_RTTI_INLINE	(	Class,
		Base
	)

Value:

public:                                                                                            \
  typedef Base                 base_type;                                                          \
  static constexpr const char* get_type_name()                                                     \
  {                                                                                                \
    OCCT_CHECK_BASE_CLASS(Class, Base);                                                            \
    return #Class;                                                                                 \
  }                                                                                                \
  static const Handle(Standard_Type)& get_type_descriptor()                                        \
  {                                                                                                \
    static const Handle(Standard_Type) THE_TYPE_INSTANCE =                                         \
      Standard_Type::Register(typeid(Class),                                                       \
                              get_type_name(),                                                     \
                              sizeof(Class),                                                       \
                              Base::get_type_descriptor());                                        \
    return THE_TYPE_INSTANCE;                                                                      \
  }                                                                                                \
  virtual const Handle(Standard_Type)& DynamicType() const Standard_OVERRIDE                       \
  {                                                                                                \
    return get_type_descriptor();                                                                  \
  }

Helper macro to be included in definition of the classes inheriting Standard_Transient to enable use of OCCT RTTI.

Inline version, does not require IMPLEMENT_STANDARD_RTTIEXT, but when used for big hierarchies of classes may cause considerable increase of size of binaries.

#define DEFINE_STANDARD_RTTIEXT	(	Class,
		Base
	)

Value:

public:                                                                                            \
  typedef Base                 base_type;                                                          \
  static constexpr const char* get_type_name()                                                     \
  {                                                                                                \
    OCCT_CHECK_BASE_CLASS(Class, Base);                                                            \
    return #Class;                                                                                 \
  }                                                                                                \
  Standard_EXPORT static const Handle(Standard_Type)&  get_type_descriptor();                      \
  Standard_EXPORT virtual const Handle(Standard_Type)& DynamicType() const Standard_OVERRIDE;

Helper macro to be included in definition of the classes inheriting Standard_Transient to enable use of OCCT RTTI.

Out-of-line version, requires IMPLEMENT_STANDARD_RTTIEXT.

#define IMPLEMENT_STANDARD_RTTIEXT	(	Class,
		Base
	)

Value:

OCCT_CHECK_BASE_CLASS(Class, Base)                                                               \
  const Handle(Standard_Type)& Class::get_type_descriptor()                                        \
  {                                                                                                \
    static const Handle(Standard_Type) THE_TYPE_INSTANCE =                                         \
      Standard_Type::Register(typeid(Class),                                                       \
                              get_type_name(),                                                     \
                              sizeof(Class),                                                       \
                              Class::base_type::get_type_descriptor());                            \
    return THE_TYPE_INSTANCE;                                                                      \
  }                                                                                                \
  const Handle(Standard_Type)& Class::DynamicType() const                                          \
  {                                                                                                \
    return STANDARD_TYPE(Class);                                                                   \
  }