C:/development/RenderTools/src/property/PointerProperty.h

Go to the documentation of this file.

#ifndef POINTERPROPERTY_H
#define POINTERPROPERTY_H

#include "Types.h"
#include "Util.h"
#include "AbstractProperty.h"
#include "AbstractPropertyContainer.h"

#include <typeinfo>

namespace RenderTools {

template< class T >
class PointerProperty : public AbstractProperty {
public:

        PointerProperty( const shared_ptr< T > & pointer ):
                AbstractProperty(),
                m_pointer( pointer ){
        }

        virtual void onInitialize( void ){

        }

        virtual const string getTypeName( bool ofComponent ) const {
                T t;
                return( RenderTools::getTypeName( t, ofComponent ) );
        }

        virtual bool isInteger( void ) const {
                T t;
                return( RenderTools::isInteger( t ) );
        }

        virtual bool isReal( void ) const {
                T t;
                return( RenderTools::isReal( t ) );
        }

        virtual bool isBoolean( void ) const {
                T t;
                return( RenderTools::isBoolean( t ) );
        }

        virtual bool isMatrix( void ) const {
                T t;
                return( RenderTools::isMatrix( t ) );
        }

        virtual bool isMultiComponent( void ) const {
                T t;
                return( RenderTools::isMultiComponent( t ) );
        }

        virtual bool setValue( const string toValue, int element = -1 ){
                string value = toValue;
                if( toValue == "" ){
                        value = string( " " );
                }
                stringstream s( AbstractPropertyContainer::interpret( value ) );
                string prevValue = getValue();
                if( typeid( * m_pointer ) == typeid( string ) ){
                        if( value == " " ){
                                noskipws( s );
                        }
                        else{
                                skipws( s );
                        }
                }
                s >> const_cast< T & >( * m_pointer );
                return( getValue() != prevValue );
        }

        virtual const string getValue( int element = -1 ) const {
                stringstream s;
                s << ( * m_pointer ) << string( " " );
                return( trim( s.str() ) );
        }

        virtual const void * getPointer( unsigned int offset ) const {
                return( ( void * ) & m_pointer.get()[ offset ] );
        }

        const shared_ptr< T > & getPointer( void ) const { 
                return( m_pointer.lock() );
        }

        shared_ptr< T > & getPointer( void ) { 
                return( m_pointer );
        }
protected:
        shared_ptr< T > m_pointer;
};

}; // namespace RenderTools


#endif

---