OBTPrimitiveAttribute.h

Go to the documentation of this file.

#ifndef OBTPrimitiveAttribute_H
#define OBTPrimitiveAttribute_H

#include "OBTRTTI.h"

namespace OBT
{
        template< class TOwner, class TAttribute, unsigned long typeID >
        class PrimitiveAttribute : public AbstractAttribute
        {
        public:

                typedef TAttribute ( TOwner::*Getter )( ) const ;               
                typedef void ( TOwner::*Setter )( TAttribute value );   

                typedef TAttribute value_type ;
                typedef TOwner owner_type ;

                PrimitiveAttribute( const char* name, Getter getter, Setter setter ) ;

                virtual ~PrimitiveAttribute() ;

                TAttribute getValue( const TOwner& owner ) const ;

                void setValue( TOwner& owner, TAttribute value ) const ;


                bool isReadOnly() const ;
                virtual const RTTI& getOwnerRTTI() const ;
                virtual const RTTI& getRTTI() const ;

                static const RTTI& getClassRTTI() ;

        private:

                Getter _getter ;

                Setter _setter ;

                static const RTTI _rtti ;
        } ;

        // RTTI initialization
        template < class TOwner, class TAttribute, unsigned long typeID >
        const RTTI PrimitiveAttribute< TOwner, TAttribute, typeID >::_rtti( typeID, typeid( PrimitiveAttribute< TOwner, TAttribute, typeID > ).name(), NULL, 1, 
                &( AbstractAttribute::getClassRTTI() ) ) ;

        //-------------------------------------------------------------------------
        // PrimitiveAttribute
        //-------------------------------------------------------------------------
        template < class TOwner, class TAttribute, unsigned long typeID >
        PrimitiveAttribute< TOwner, TAttribute, typeID >::PrimitiveAttribute( const char* name, Getter getter, Setter setter )
                :
        AbstractAttribute( name ),
                _getter( getter ),
                _setter( setter )
        {
                OBT_DBG_ASSERT( _getter != NULL ) ;
        }

        //-------------------------------------------------------------------------
        // ~PrimitiveAttribute
        //-------------------------------------------------------------------------
        template < class TOwner, class TAttribute, unsigned long typeID >
        PrimitiveAttribute< TOwner, TAttribute, typeID >::~PrimitiveAttribute( )
        {   
        }

        //-------------------------------------------------------------------------
        // isReadOnly()
        //-------------------------------------------------------------------------
        template < class TOwner, class TAttribute, unsigned long typeID >
        bool
                PrimitiveAttribute< TOwner, TAttribute, typeID >::isReadOnly() const
        {
                return ( _setter == NULL ) ;
        }

        //-------------------------------------------------------------------------
        // getValue()
        //-------------------------------------------------------------------------
        template < class TOwner, class TAttribute, unsigned long typeID >
        TAttribute
                PrimitiveAttribute< TOwner, TAttribute, typeID >::getValue( const TOwner& owner ) const
        {
                return ( owner.*_getter )() ;
        }

        //-------------------------------------------------------------------------
        // setValue()
        //-------------------------------------------------------------------------
        template < class TOwner, class TAttribute, unsigned long typeID >
        void 
                PrimitiveAttribute< TOwner, TAttribute, typeID >::setValue( TOwner& owner, TAttribute value ) const
        {
                // Cannot write to a read-only attribute.
                OBT_DBG_ASSERT( isReadOnly( ) == false ) ;
                ( owner.*_setter )( value ) ;
        }

        //-------------------------------------------------------------------------
        // getOwnerRTTI
        //-------------------------------------------------------------------------
        template < class TOwner, class TAttribute, unsigned long typeID >
        const RTTI& 
                PrimitiveAttribute< TOwner, TAttribute, typeID >::getOwnerRTTI() const
        {
                return TOwner::getClassRTTI() ;
        }

        //-------------------------------------------------------------------------
        // getRTTI
        //-------------------------------------------------------------------------
        template < class TOwner, class TAttribute, unsigned long typeID >
        const RTTI& 
                PrimitiveAttribute< TOwner, TAttribute, typeID >::getRTTI ( ) const
        {
                return _rtti ;
        }

        //-------------------------------------------------------------------------
        // getClassRTTI
        //-------------------------------------------------------------------------
        template < class TOwner, class TAttribute, unsigned long typeID >
        const RTTI& 
                PrimitiveAttribute< TOwner, TAttribute, typeID >::getClassRTTI( )
        {
                return _rtti ;
        }

        template < class TOwner > 
        class BoolAttribute : public PrimitiveAttribute< TOwner, bool, 1991421614 >
        {
        public :

                BoolAttribute( const char* name, Getter getter, Setter setter )
                        :
                PrimitiveAttribute< TOwner, bool, 1991421614 >( name, getter, setter )
                {}
        } ;

        template < class TOwner > 
        class ShortAttribute : public PrimitiveAttribute< TOwner, short, 1933918052 >
        {
        public :

                ShortAttribute( const char* name, Getter getter, Setter setter )
                        :
                PrimitiveAttribute< TOwner, short, 1933918052 >( name, getter, setter )
                {}
        } ;

        template < class TOwner > 
        class UnsignedShortAttribute : public PrimitiveAttribute< TOwner, unsigned short, 2009635584 >
        {
        public :

                UnsignedShortAttribute( const char* name, Getter getter, Setter setter )
                        :
                PrimitiveAttribute< TOwner, unsigned short, 2009635584 >( name, getter, setter )
                {}
        } ;

        template < class TOwner > 
        class IntAttribute : public PrimitiveAttribute< TOwner, int, 2240172011 >
        {
        public :

                IntAttribute( const char* name, Getter getter, Setter setter )
                        :
                PrimitiveAttribute< TOwner, int, 2240172011 >( name, getter, setter )
                {}
        } ;

        template < class TOwner > 
        class UnsignedIntAttribute : public PrimitiveAttribute< TOwner, unsigned int, 1543155168 >
        {
        public :

                UnsignedIntAttribute( const char* name, Getter getter, Setter setter )
                        :
                PrimitiveAttribute< TOwner, unsigned int, 1543155168 >( name, getter, setter )
                {}
        } ;

        template < class TOwner > 
        class LongAttribute : public PrimitiveAttribute< TOwner, long, 1468120404 >
        {
        public :

                LongAttribute( const char* name, Getter getter, Setter setter )
                        :
                PrimitiveAttribute< TOwner, long, 1468120404 >( name, getter, setter )
                {}
        } ;

        template < class TOwner > 
        class UnsignedLongAttribute : public PrimitiveAttribute< TOwner, unsigned long, 3266407847 >
        {
        public :

                UnsignedLongAttribute( const char* name, Getter getter, Setter setter )
                        :
                PrimitiveAttribute< TOwner, unsigned long, 3266407847 >( name, getter, setter )
                {}
        } ;

        template < class TOwner > 
        class FloatAttribute : public PrimitiveAttribute< TOwner, float, 1498253751 >
        {
        public :

                FloatAttribute( const char* name, Getter getter, Setter setter )
                        :
                PrimitiveAttribute< TOwner, float, 1498253751 >( name, getter, setter )
                {}
        } ;

        template < class TOwner > 
        class DoubleAttribute : public PrimitiveAttribute< TOwner, double, 1608088171 >
        {
        public :

                DoubleAttribute( const char* name, Getter getter, Setter setter )
                        :
                PrimitiveAttribute< TOwner, double, 1608088171 >( name, getter, setter )
                {}
        } ;

        template < class TOwner > 
        class StringAttribute : public PrimitiveAttribute< TOwner, const char*, 1135290523 >
        {
        public :

                StringAttribute( const char* name, Getter getter, Setter setter )
                        :
                PrimitiveAttribute< TOwner, const char*, 1135290523 >( name, getter, setter )
                {}
        } ;
}
#endif //header

---