C:/development/RenderTools/src/property/AbstractProperty.cpp

Go to the documentation of this file.

#include "AbstractProperty.h"
#include "AbstractPropertyContainer.h"
#include "Error.h"
#include "Util.h"
#include "XMLNode.h"
#include "Factory.h"
#include <typeinfo>

namespace RenderTools {

map< string, PropertyWeakPtr >          AbstractProperty::s_paths;
unsigned long                                           AbstractProperty::s_counter = 0;

AbstractProperty::AbstractProperty( void ):
        m_semantic( NONE ),
        m_name( createName() ){
}

void AbstractProperty::setName( const XMLNodePtr & xml ){

        string name;

        if( xml ){
                if( Factory::isRegisteredClass( xml->getTagName() ) ){
                        if( xml->hasAttrib( "name" ) ){ 
                                name = xml->getAttrib<string>( "name" );
                        }
                        else{
                                name = createName();
                        }
                }
                else{
                        name = xml->getTagName();
                }
        }
        else{
                name = createName();
        }

        setName( name );
}

void AbstractProperty::setName( const string name ){

        removePath();

        m_name = name;

        if( m_name == "" ){
                m_name = createName();
        }

        storePath();
}

void AbstractProperty::recalculatePath( void ){
        removePath();
        storePath();
}

void AbstractProperty::removePath( void ){

        map< string, PropertyWeakPtr >::iterator i1 = s_paths.begin();
        for( ; i1 != s_paths.end(); i1++ ){
                if( i1->second.lock().get() == this ){
                        s_paths.erase( i1 );
                        break;
                }
        }

}

void AbstractProperty::storePath( void ){
        m_path = tracePath();
        s_paths[ m_path ] = getWeakPtr< AbstractProperty >();
}

#ifdef RT_PROFILER
void AbstractProperty::beginProfiler( string name, string file, int line ){
        string decoratedName = m_name + "[" + name + "]";

        map<string, Profiler *>::iterator i;
        Profiler * p = 0;
        if( ( i = m_profilers.find( decoratedName ) ) == m_profilers.end() ){
                p = new Profiler( decoratedName, file, line );
                m_profilers[ decoratedName ] = p;
        }
        else{
                p = i->second;
        }
        if( p ){
                p->begin();
        }
        else{
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__ );
        }
}

void Property::endProfiler( string name ){
        map<string, Profiler *>::iterator i;
        if( ( i = m_profilers.find( m_name + "[" + name + "]" ) ) == m_profilers.end() ){
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__ );
        }
        else{
                i->second->end();
        }
}

const map<string, Profiler *> & Property::getProfilers( void ){
        return( m_profilers );
}

#endif

const string & AbstractProperty::getPath( void ) const {
        return( m_path );
}

const string AbstractProperty::createName( const string prefix ){
        return( prefix + toString( s_counter++ ) );
}

AbstractProperty::~AbstractProperty( void ){

        removePath();

        PropertyPtr thisPtr = getNullDeletingSharedPtr< AbstractProperty >();

        if( m_owner.lock().get() ){
                m_owner.lock()->removeProperty( thisPtr, true );
        }

        while( m_eventListeners.size() ){
                PropertyPtr listener = m_eventListeners[ 0 ].lock();
                if( listener ){
                        listener->disconnect( thisPtr, true );
                }
        }

#ifdef RT_PROFILER
        map<string, Profiler *>::iterator i = m_profilers.begin();
        for( ; i != m_profilers.end(); i++ ){
                delete i->second;
        }
        m_profilers.clear();
#endif

}

void AbstractProperty::clear( void ){
        s_paths.clear();
}

const PropertyPtr AbstractProperty::find( const string path ){
        if( path == "" ){
                Error::error( Error::EMPTY_PATH, __FILE__, __LINE__ );
        }
        map< string, PropertyWeakPtr >::iterator i = s_paths.begin();
        for( ; i != s_paths.end(); i++ ){
                if( i->first.rfind( path ) != string::npos ){
                        return( i->second.lock() );
                }
        }
        return( PropertyPtr() );
}

const string AbstractProperty::find( const PropertyPtr & p ){
        map< string, PropertyWeakPtr >::iterator i = s_paths.begin();
        for( ; i != s_paths.end(); i++ ){
                if( i->second.lock() == p ){
                        return( i->first );
                }
        }
        return( "" );
}

const XMLNodePtr AbstractProperty::toXML( const XMLNodePtr & parent ) const {
        XMLNodePtr xml( new XMLNode( m_name ) );
        if( parent ){
                parent->addChild( xml );
        }
        xml->setAttrib<string>( "type", getTypeName() );
        xml->setAttrib<string>( "value", getValue() );
        return( xml );
}

void AbstractProperty::sendPropertyEvent( const PropertyEvent & e ){
        onPropertyEvent( e );
        for( unsigned int i = 0; i < m_eventListeners.size(); i++ ){
                PropertyPtr listener = m_eventListeners[ i ].lock();
                if( listener ){
                        listener->onPropertyEvent( e );
                }
        }
}

void AbstractProperty::addEventListener( const PropertyPtr & p, bool send ){
        m_eventListeners.push_back( p );
}

void AbstractProperty::removeEventListener( const PropertyPtr & p, bool send ){
        for( unsigned int i = 0; i < m_eventListeners.size(); i++ ){
                PropertyPtr listener = m_eventListeners[ i ].lock();
                if( listener == p ){
                        m_eventListeners[ i ] = m_eventListeners[ m_eventListeners.size() - 1 ];
                        m_eventListeners.pop_back();
                        return;
                }
        }
}

void AbstractProperty::connect( const PropertyPtr & p, bool send ){
        p->addEventListener( getSharedPtr< AbstractProperty >(), send );
        addEventListener( p, send );
        sendPropertyEvent( PropertyEvent( PropertyEvent::CONNECT, p ) );
}

void AbstractProperty::disconnect( const PropertyPtr & p, bool send ){
        sendPropertyEvent( PropertyEvent( PropertyEvent::DISCONNECT, p ) );
        p->removeEventListener( getSharedPtr< AbstractProperty >(), send );
        removeEventListener( p, send );
}

void AbstractProperty::onPropertyEvent( const PropertyEvent & e ){

}

void AbstractProperty::createProperties( void ){

}

void AbstractProperty::onInitialize( void ){

}

const string AbstractProperty::tracePath( void ) const {
        PropertyContainerPtr parent = getOwner();
        string path = m_name;
        vector< PropertyContainerPtr > visited;
        while( parent ){
                bool cycle = false;
                for( unsigned int i = 0; i < visited.size(); i++ ){
                        if( visited[ i ] == parent ){
                                cycle = true;
                                break;
                        }
                }
                if( cycle ){
                        break;
                }
                path = ( parent->getName() == "" ? "" : ( parent->getName() + '.' ) ) + path;
                visited.push_back( parent );
                parent = parent->getOwner() == parent ? PropertyContainerPtr() : parent->getOwner();
        }

        return( path );
}

void AbstractProperty::setOwner( const PropertyContainerPtr & owner ){

        removePath();

        m_owner = owner;

        storePath();
}

const PropertyContainerPtr AbstractProperty::getOwner( void ) const {
        return( m_owner.lock() );
}

const string & AbstractProperty::getName( void ) const {
        return( m_name ); 
}

const string AbstractProperty::getTypeName( bool ofComponent ) const {
        return( "AbstractProperty" );
}

const string    AbstractProperty::getDecoratedName( bool includeType, bool asVector, int vectorElement, int component ) const {
        stringstream name;
        if( includeType ){
                string type = getTypeName( component >= 0 );
                if( asVector ){
                        name << "vector<" << type << ">";
                }
        }

        name << m_name;

        if( vectorElement >= 0 ){
                if( isVector( ) ){
                        name << '[' << vectorElement << ']';
                }
        }
        return( name.str() ); 
}

AbstractProperty::SemanticMask AbstractProperty::getSemantic( void ) const {
        return( m_semantic ); 
}

void AbstractProperty::setSemantic( SemanticMask semantic ){
        m_semantic = semantic;
        sendPropertyEvent( PropertyEvent( PropertyEvent::CHANGED, getSharedPtr< AbstractProperty >() ) );
}

const string AbstractProperty::getValue( int vectorElement ) const {
        return( "" );
}

bool AbstractProperty::setValue( const string value, int vectorElement ) {
        return( false );
}

const void * AbstractProperty::getPointer( unsigned int offset ) const {
        return( 0 );
}

unsigned int AbstractProperty::getNumVectorElements( void ) const {
        return( 0 );
}

unsigned int AbstractProperty::getNumComponents( void ) const {
        return( 1 );
}

bool AbstractProperty::isContainer( void ) const {
        return( false );
}

bool AbstractProperty::isString( void ) const {
        return( false );
}

bool AbstractProperty::isInteger( void ) const {
        return( false );
}

bool AbstractProperty::isReal( void ) const {
        return( false );
}

bool AbstractProperty::isBoolean( void ) const {
        return( false );
}

bool AbstractProperty::isMatrix( void ) const {
        return( false );
}

bool AbstractProperty::isEnum( void ) const {
        return( false );
}

bool AbstractProperty::isMultiComponent( void ) const {
        return( false );
}

bool AbstractProperty::isVector( void ) const {
        return( false );
}

ostream & operator << ( ostream & os, const AbstractProperty & rhs ){
        return( os << rhs.getName() << "::" << rhs.getValue() );
}

const istream & operator >> ( const istream & is, AbstractProperty & rhs ){
        string s( ( istreambuf_iterator<char>( is.rdbuf() ) ), istreambuf_iterator<char>( ) );
        rhs.setValue( s );
        return( is );
}

}; // namespace

---