CObject.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "rtti-precomp.h"  // Precompiled headers
 
#include <mrpt/rtti/CObject.h>
#include <cstdio>
#include "internal_class_registry.h"
 
using namespace mrpt;
using namespace mrpt::rtti;
 
const mrpt::rtti::TRuntimeClassId& CObject::GetRuntimeClassIdStatic()
{
        return CObject::runtimeClassId;
}
 
bool TRuntimeClassId::derivedFrom(const TRuntimeClassId* pBaseClass) const
{
        ASSERT_(pBaseClass != nullptr);
 
        // The same class??
        if (pBaseClass == this) return true;
 
        // Automatically register all pending classes, just in case:
        registerAllPendingClasses();
 
        // Check heritage:
        const TRuntimeClassId* pClassThis = this;
        while (pClassThis != nullptr)
        {
                if (pClassThis == pBaseClass) return true;
 
                if (pClassThis->getBaseClass)
                        pClassThis = (*pClassThis->getBaseClass)();
                else
                        pClassThis = nullptr;  // The root class
        }
 
        // Parent class not found
        return false;
}
 
bool TRuntimeClassId::derivedFrom(const char* pBaseClass_name) const
{
        // Automatically register all pending classes, just in case:
        registerAllPendingClasses();
 
        const TRuntimeClassId* pBaseClass = findRegisteredClass(pBaseClass_name);
        ASSERTMSG_(
                pBaseClass != nullptr,
                format("Class %s not registered??", pBaseClass_name));
 
        // The same class??
        if (pBaseClass == this) return true;
 
        // Check heritage:
        const TRuntimeClassId* pClassThis = this;
        while (pClassThis != nullptr)
        {
                if (pClassThis == pBaseClass) return true;
 
                if (pClassThis->getBaseClass)
                        pClassThis = (*pClassThis->getBaseClass)();
                else
                        pClassThis = nullptr;  // The root class
        }
 
        // Parent class not found
        return false;
}
 
CObject* TRuntimeClassId::createObject() const
{
        if (!ptrCreateObject)
        {
                fprintf(
                        stderr,
                        "[TRuntimeClassId::createObject] Trying to create an object "
                        "without dynamic constructor. classname=`%s`\n",
                        className != nullptr ? className : "nullptr");
                return nullptr;
        }
 
        try
        {
                CObject* ret = (*ptrCreateObject)();
                return ret;
        }
        catch (std::bad_alloc&)
        {
                throw;
        }
}
 
// For class CObject, special methods must be defined
// since it has no base class. These methods are defined
// automatically for derived classes.
TRuntimeClassId* CObject::_GetBaseClass() { return nullptr; }
const struct TRuntimeClassId CObject::runtimeClassId = {"CObject", nullptr,
                                                                                                                nullptr};
 
mrpt::rtti::CObject* mrpt::rtti::classFactory(const std::string& className)
{
        auto pR = findRegisteredClass(className);
        if (!pR) return nullptr;
        return pR->createObject();
}
 
mrpt::rtti::CObject::Ptr mrpt::rtti::classFactoryPtr(
        const std::string& className)
{
        mrpt::rtti::CObject::Ptr ret;
        auto pR = findRegisteredClass(className);
        if (pR) ret.reset(pR->createObject());
        return ret;
}