OBTRTTI.cpp

Go to the documentation of this file.

#include <cstdarg>

#include "OBTRTTI.h"

using namespace std ;
using namespace OBT ;

//------------------------------------------------------------------------------------------
// constructor
//------------------------------------------------------------------------------------------
RTTI::RTTI( TypeID typeID, const char* name, RegisterAttributesFunc registerFunc, unsigned int ancestorsCount, ... ) 
                        : 
_typeID( typeID ),
_typeName( name )
{
        OBT_DBG_ASSERT( typeID != 0 ) ;
        OBT_DBG_ASSERT( name != 0 ) ;

        // register the inspectable attributes.
        if ( registerFunc != NULL )
        {
                registerFunc() ;
        }

        // set the ancestors for this RTTI.
        if ( ancestorsCount != 0 )
        {
                va_list marker;
                // initialize variable arguments.
                va_start( marker, ancestorsCount );

                for ( unsigned int ancestor = 0; ancestor < ancestorsCount; ++ancestor )
                {
                        RTTI* tmp( va_arg( marker, RTTI* ) ) ;
                        _baseClassesRTTI.push_back( tmp ) ;
                }
                va_end( marker ) ;
        }
}

//------------------------------------------------------------------------------------------
// destructor
//------------------------------------------------------------------------------------------
RTTI::~RTTI()
{
        std::vector< const AbstractAttribute* >::iterator ite( _attributes.begin() ) ;
        for ( ; ite != _attributes.end() ; ++ite )
        {
                delete *ite ;
        }
}

//-------------------------------------------------------------------------
// isDerivedFrom
//-------------------------------------------------------------------------
bool 
RTTI::isDerivedFrom( const RTTI& rtti ) const
{
        if( _typeID == rtti.getTypeID() )
        {
                return true ;
        }

        // perform a depth-first search for an ancestor with typeID.
        std::vector< const RTTI* >::const_iterator ite( _baseClassesRTTI.begin() ) ;
        for ( ; ite != _baseClassesRTTI.end() ; ++ite )
        {
                if ( ( *ite )->isDerivedFrom( rtti ) )
                {
                        return true ;
                }
        }
        return false;
}

//-------------------------------------------------------------------------
// getAttribute
//-------------------------------------------------------------------------
const AbstractAttribute* 
const RTTI::getAttribute( unsigned int attributeNumber ) const 
{
        unsigned int attributesCount( 0 );
        std::vector< const RTTI* >::const_iterator ite( _baseClassesRTTI.begin() ) ;
        // get the ancestor actually owning the attribute (if it exists)
        for ( ; ite != _baseClassesRTTI.end() ; ++ite )
        {
                attributesCount = ( *ite )->getAttributesCount() ;
                if ( attributeNumber < attributesCount )
                {
                        // found the right ancestor : get the attribute from it.
                        return ( *ite )->getAttribute( attributeNumber ) ;
                }
                else
                {
                        // proceed to the next ancestor
                        attributeNumber -= attributesCount ;
                }
        } 
        // the attribute actually belongs to this class, return it.
        return _attributes.at( attributeNumber ) ;
}       

//-------------------------------------------------------------------------
// getAttribute
//-------------------------------------------------------------------------
const AbstractAttribute* const 
RTTI::getAttribute( const char* name ) const 
{
        std::string str( name ) ;
        std::vector< const AbstractAttribute* >::const_iterator ite( _attributes.begin() ) ;
        // look for the queried attribute in this instance.
        for ( ; ite != _attributes.end() ; ++ite )
        {
                if ( ( *ite )->getName() == str )
                {
                        return *ite ;
                }
        }

        // attribute was not found : search through the ancestors tree.
        std::vector< const RTTI* >::const_iterator ancestorIte( _baseClassesRTTI.begin() ) ;
        for ( ; ancestorIte != _baseClassesRTTI.end() ; ++ancestorIte )
        {
                const AbstractAttribute* const attribute( ( *ancestorIte )->getAttribute( name ) ) ;
                if ( attribute != NULL )
                {
                        return attribute ;
                }
        }
        return NULL ;
}

---