OBTRTTI.h

Go to the documentation of this file.

#ifndef OBTRTTI_H
#define OBTRTTI_H

#include <vector>

#include "OBTAbstractAttribute.h"
#include "OBT_ASSERT.h"

namespace OBT
{
        typedef unsigned long TypeID ;

        class OBT_API RTTI
        {

        public:

                typedef void ( *RegisterAttributesFunc )() ;

                RTTI( TypeID typeID, const char* name, RegisterAttributesFunc registerFunc, unsigned int ancestorsCount, ... ) ;

                virtual ~RTTI() ;

                bool isDerivedFrom( const RTTI& rtti ) const ;

                const RTTI& getAncestorRTTI( unsigned int ancestor ) const ;

                unsigned int getAncestorsCount() const;

                TypeID getTypeID() const ;

                const char* getTypeName() const;

                unsigned int getAttributesCount( ) const ;

                const AbstractAttribute* const getAttribute( unsigned int attributeNumber ) const ;

                template< class TAttribute >
                const TAttribute* const getAttribute( unsigned int attributeNumber ) const ;

                const AbstractAttribute* const getAttribute( const char* name ) const ;

                template< class TAttribute >
                const TAttribute* const getAttribute( const char* name ) const ;

                template <class TAttribute>
                void registerAttribute( const TAttribute& attrib ) const ;

        private:

                const TypeID _typeID ;

                const std::string _typeName ;

                std::vector< const RTTI* > _baseClassesRTTI ;

                mutable std::vector< const AbstractAttribute* > _attributes ;

                RTTI( const RTTI& rtti ) ;

                const RTTI& operator=( const RTTI& rtti ) ;
        } ;

        //-------------------------------------------------------------------------
        // getAncestorRTTI
        //-------------------------------------------------------------------------
        inline const RTTI&
                RTTI::getAncestorRTTI( unsigned int ancestor ) const
        {
                return *_baseClassesRTTI.at( ancestor ) ;
        }

        //-------------------------------------------------------------------------
        // getAncestorsCount
        //-------------------------------------------------------------------------
        inline unsigned int
                RTTI::getAncestorsCount() const
        {
                return static_cast<unsigned int>( _baseClassesRTTI.size() );
        }

        //-------------------------------------------------------------------------
        // getTypeID
        //-------------------------------------------------------------------------
        inline TypeID 
                RTTI::getTypeID() const
        {
                return _typeID ;
        }

        //-------------------------------------------------------------------------
        // getTypeID
        //-------------------------------------------------------------------------
        inline const char* 
                RTTI::getTypeName() const
        {
                return _typeName.c_str() ;
        }

        //-------------------------------------------------------------------------
        // getAttributesCount
        //-------------------------------------------------------------------------
        inline unsigned int 
                RTTI::getAttributesCount( ) const 
        {
                unsigned int attributesCount( static_cast<unsigned int>( _attributes.size() ) ) ;
                std::vector< const RTTI* >::const_iterator ite( _baseClassesRTTI.begin() ) ;
                for ( ; ite != _baseClassesRTTI.end() ; ++ite )
                {
                        attributesCount += ( *ite )->getAttributesCount( ) ;
                }
                return attributesCount ;
        }

        //-------------------------------------------------------------------------
        // getAttribute
        //-------------------------------------------------------------------------
        template< class TAttribute >
        const TAttribute* 
                const RTTI::getAttribute( unsigned int attributeNumber ) const 
        {
                const AbstractAttribute* const attribute( getAttribute( attributeNumber ) ) ;
                if ( attribute == NULL )
                {
                        return NULL ; 
                }
                else
                {
                        OBT_DBG_ASSERT( ( ( TAttribute::getClassRTTI().getTypeID() == attribute->getRTTI().getTypeID() ) &&
                                TAttribute::owner_type::getClassRTTI().getTypeID() == attribute->getOwnerRTTI().getTypeID() ) ) ;
                        return ( static_cast< const TAttribute* const >( attribute ) ) ;
                }
        }       

        //-------------------------------------------------------------------------
        // getAttribute
        //-------------------------------------------------------------------------
        template< class TAttribute >
        const TAttribute* 
                const RTTI::getAttribute( const char* name ) const 
        {
                const AbstractAttribute* const attribute( getAttribute( name ) ) ;
                if ( attribute == NULL )
                {
                        return NULL ; 
                }
                else
                {
                        OBT_DBG_ASSERT( ( ( TAttribute::getClassRTTI().getTypeID() == attribute->getRTTI().getTypeID() ) &&
                                TAttribute::owner_type::getClassRTTI().getTypeID() == attribute->getOwnerRTTI().getTypeID() ) ) ;
                        return ( static_cast< const TAttribute* const >( attribute ) ) ;
                }
        }

        //-------------------------------------------------------------------------
        // registerAttribute
        //-------------------------------------------------------------------------
        template< class TAttribute >
        inline void 
                RTTI::registerAttribute( const TAttribute& attribute ) const
        {
                _attributes.push_back( new TAttribute( attribute ) ) ;
        }
}

#endif //__RTTI_H__

---