#include "cetl/rtti.hpp"

Public Member Functions

virtual CETL_NODISCARD void *	_cast_ (const type_id &id) &noexcept=0

virtual CETL_NODISCARD const void *	_cast_ (const type_id &id) const &noexcept=0

Detailed Description

An alternative implementation of simple runtime type information (RTTI) capability designed for high-integrity real-time systems, where the use of the standard C++ RTTI is discouraged.

Unlike the standard C++ RTTI, this implementation requires the user to manually specify the type ID per type in the form of a 16-byte UUID (GUID). The capabilities include querying runtime type information in constant time and performing safe dynamic type down-conversion (and up-conversion, similar to dynamic_cast) in constant time, including the case of multiple inheritance.

The limitations are that a type has to opt into this RTTI capability explicitly (it doesn't work for all types) and that CV-qualifiers and references are not considered in the type comparison; that is, T and const T& are considered the same type.

In order to support this RTTI capability, a type must at least define a public method static constexpr cetl::type_id get_type_id() noexcept that returns the type ID (i.e., the UUID) of the type it is defined on. Types that provide said method satisfy cetl::has_type_id.

If the type is polymorphic, it should either manually implement cetl::rtti through virtual inheritance, or use the cetl::rtti_helper helper which will provide the necessary implementation of the RTTI-related methods along with the aforementioned _get_type_id_() method. More about the latter option in its documentation.

Attention: Use only virtual inheritance when deriving from this type.

RTTI-related members are named with surrounding underscores to avoid name clashes with user-defined members, including the members of DSDL types (where identifiers surrounded with underscores are reserved). The user code should not invoke such underscored methods directly but instead use the free functions defined here.

A basic usage example:

class ICat final : public virtual cetl::rtti  // <-- use virtual inheritance when implementing cetl::rtti
{
public:
static constexpr cetl::type_id _get_type_id_() noexcept { return cetl::type_id_type_value<0x12>; }
void* _cast_(const cetl::type_id& id) & noexcept override
{
    return (id == _get_type_id_()) ? static_cast<void*>(this) : nullptr;
}
const void* _cast_(const cetl::type_id& id) const& noexcept override
{
    return (id == _get_type_id_()) ? static_cast<const void*>(this) : nullptr;
}
};
 
class Tabby final : public ICat
{
public:
static constexpr cetl::type_id _get_type_id_() noexcept { return cetl::type_id_type_value<0x34>; }
void* _cast_(const cetl::type_id& id) & noexcept override
{
    if (id == _get_type_id_()) { return static_cast<void*>(this); }
    return ICat::_cast_(id);
}
const void* _cast_(const cetl::type_id& id) const& noexcept override
{
    if (id == _get_type_id_()) { return static_cast<const void*>(this); }
    return ICat::_cast_(id);
}
};
 
void foo(ICat& some_cat)
{
// you can query the cat directly:
const is_tabby = cetl::is_instance_of<Tabby>(some_cat);
// or you can try converting it and see if it succeeds:
Tabby* maybe_tabby = cetl::rtti_cast<Tabby*>(&some_cat);
}

A basic usage example with a class implementing multiple interfaces:

//Assume that Tabby and Boxer are polymorphic types that implement the cetl::rtti interface.
class CatDog final : public Tabby, public Boxer
{
public:
void* _cast_(const type_id& id) & noexcept override
{
    if (void* const p = Tabby::_cast_(id)) { return p; }
    return Boxer::_cast_(id);
}
const void* _cast_(const type_id& id) const& noexcept override
{
    if (const void* const p = Tabby::_cast_(id)) { return p; }
    return Boxer::_cast_(id);
}
};

A similar example with composition:

class CatDog final : public virtual cetl::rtti
{
public:
void* _cast_(const type_id& id) & noexcept override
{
    if (void* const p = m_cat._cast_(id)) { return p; }
    return m_dog._cast_(id);
}
const void* _cast_(const type_id& id) const& noexcept override
{
    if (const void* const p = m_cat._cast_(id)) { return p; }
    return m_dog._cast_(id);
}
private:
// Assume that Tabby and Boxer are polymorphic types that implement the cetl::rtti interface.
Tabby m_cat{};
Boxer m_dog{};
};

Member Function Documentation

◆ _cast_() [1/2]

virtual CETL_NODISCARD void * cetl::rtti::_cast_ ( const type_id & id ) &

pure virtualnoexcept

Implementations can choose to use cetl::rtti_helper instead of implementing this manually.

If manual implementation is preferred, then the method body should be implemented as follows (add const in the const overload):

return (id == _get_type_id_()) ? static_cast<void*>(this) : base::_cast_(id);

Where base is the base class of the current class that implements this method, if any; if there is more than one base available, all of those that implement this cetl::rtti interface should be checked in the same way one by one and the first match (non-nullptr result) should be returned.

The objective here is to check if the current type in the hierarchy is the one being sought; if not, delegate the call to the base class(es); the topmost class is this rtti type that simply returns a null pointer, indicating that the search has returned no matches and a safe dynamic type conversion is not possible (at least not along the current branch of the type tree).

This method should not be invoked directly; instead, use cetl::rtti_cast.

Implemented in cetl::rtti_helper< TypeIDType, Bases >, cetl::rtti_helper< function_handler_typeid_t >, and cetl::rtti_helper< functor_handler_typeid_t, function_handler< Result, Args... > >.

References CETL_NODISCARD.

◆ _cast_() [2/2]

virtual CETL_NODISCARD const void * cetl::rtti::_cast_ ( const type_id & id ) const &