RTFXObject.h

Go to the documentation of this file.

#ifndef __RTFX_OBJECT__
#define __RTFX_OBJECT__

#include "RTFXBoostIncludes.h"
#include "RTFXMath.h"
#include "RTFXRecorder.h"
#include "RTFXHelpers.h"
#include "RTFXPropertyIncludes.h"
#include "RTFX_API.h"

using namespace std;

namespace RTFX
{

    class RTFXAPI RTFXObject
    {
        public:

            enum RTFXObjectType
            {
                NONE = 0,           
                CAMERA = 1,         
                LIGHT = 2,          
                GEOMETRY = 3,       
                POINT = 4,          
                FACE = 5,           
                BONE = 6,           
                SKELETON = 7,       
                PARTICLESYSTEM = 8, 
                RAW = 9,            
                TRANSFORM = 10,     
                SCRIPT = 11,        
                CUSTOM = 254,       
            };

            RTFXObject() : hasChanged( true ), shouldBeDeleted( false ), shouldBeResent( false ), isPartial( false )
            {
                // Set default OWNER and ID
                id = boost::uuids::nil_uuid();
                owner = boost::uuids::nil_uuid();

                // Initialize the base property ID
                nextPropertyID = 0;

                isNew = true;

                // Create the name property
                RTFXPropertyString * nameProperty = new RTFXPropertyString();
                nameProperty->SetAll( "name", "name of property", true, GetANewPropertyID() );
                nameProperty->SetDataType( RTFXProperty::DATASTRING );
                nameProperty->SetValue( "object" );
                nameProperty->SetBasis( false );

                propertyMap[ nameProperty->GetID() ] = nameProperty;
                propertyNameLookup[ nameProperty->GetName() ] = nameProperty->GetID();
                nameProperty->SetOwner( id );
                name = "object";
            }

            virtual ~RTFXObject() 
            {
                debug( ostringstream().flush() << "RTFXObject::Destructor: " << name << endl );
                // Erase the elements of the propertyNameLookups
                DeleteAllProperties();

                nextPropertyID = 0;
            };


            RTFXObject( const RTFXObject &_o )
            {
                debug( ostringstream().flush() << "RTFXObject::Copy Constructor: copying data - " << _o.name << endl );
                // Set the RTFXObject base properties
                SetType( _o.type );

                SetID( _o.id );

                SetChanged( true );
                SetDeleteMe( _o.shouldBeDeleted );
                SetResend( _o.shouldBeResent );
                SetPartial( _o.isPartial );
                SetName( _o.name );
                SetDescription( _o.description );
                SetNew( _o.isNew );

                CopyProperties( &_o );

                SetIsInstance( _o.isInstance );
                SetInstanceOfID( _o.instanceOfID );
            }

            RTFXObjectType GetType() 
            { 
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                return type; 
            }

            void SetType( RTFXObjectType _type ) 
            { 
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                type = _type; 
            }

            boost::uuids::uuid GetID() 
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                return id; 
            }

            void SetID( boost::uuids::uuid _id ) 
            { 
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                id = _id; 
                RTFXPropertyString * ptr_ = ( RTFXPropertyString * )GetProperty( "name" );
                ptr_->SetOwner( id );
            }

            boost::uuids::uuid GetOwner() 
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                return owner; 
            }

            void SetOwner( boost::uuids::uuid _owner ) 
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                owner = _owner; 
            }

            bool GetChanged() 
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                return hasChanged; 
            }

            void SetChanged( bool _changed ) 
            { 
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                hasChanged = _changed; 
            }

            bool GetDeleteMe() { return shouldBeDeleted; }

            void SetDeleteMe( bool _deleteme ) { shouldBeDeleted = _deleteme; }

            bool GetResend() { return shouldBeResent; }

            void SetResend( bool _resend ) { shouldBeResent = _resend; }

            bool GetPartial() 
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                return isPartial; 
            }

            void SetPartial( bool _partial ) 
            {               
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                isPartial = _partial; 
            }

            std::string GetName() 
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                RTFXPropertyString * ptr_ = ( RTFXPropertyString * )GetProperty( "name" );
                name = ptr_->GetValue();
                return name; 
            }

            void SetName( std::string _name ) 
            { 
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                name = _name; 
                RTFXPropertyString * tmp_ = (RTFXPropertyString *)GetProperty( "name" );
                tmp_->SetValue( _name );
            }

            std::string GetDescription() 
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                return description; 
            }

            void SetDescription( std::string _description ) 
            { 
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                description = _description; 
            }

            void AddProperty( RTFXProperty * _property )
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                if ( PropertyExists( _property->GetName() ) )
                    return;

                if ( _property->GetID() == 0 && nextPropertyID != 0 )
                {
                    _property->SetID( nextPropertyID );
                    nextPropertyID ++;
                }

                propertyMap[ _property->GetID() ] = _property;
                propertyNameLookup[ _property->GetName() ] = _property->GetID();
                _property->SetOwner( id );
            }

            bool PropertyExists( unsigned int _id )
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                if ( propertyMap.find( _id ) == propertyMap.end() )
                    return false;
                return true;
            }

            bool PropertyExists( std::string _propertyName )
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                if ( propertyNameLookup.find( _propertyName ) == propertyNameLookup.end() )
                    return false;
                return true;
            }

            unsigned int GetANewPropertyID()
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                unsigned int returnValue_ = nextPropertyID;
                nextPropertyID ++;

                return returnValue_;
            }

            RTFXProperty * GetProperty( std::string _propertyName )
            {
                // Lookup the id of the property
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                unsigned int propertyID_ = propertyNameLookup[ _propertyName ];
                return propertyMap[ propertyID_ ];
            }

            RTFXProperty * GetProperty( unsigned int _id )
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                return propertyMap[ _id ];
            }

            void DeleteProperty( unsigned int _id )
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );

                RTFXProperty * ptr_ = GetProperty( _id );
                propertyMap.erase( _id );
                propertyNameLookup.erase( ptr_->GetName() );

                delete ptr_;
            }

            void DeletePropertyByName( std::string _propertyName )
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );

                RTFXProperty * ptr_ = GetProperty( _propertyName );
                propertyMap.erase( ptr_->GetID() );
                propertyNameLookup.erase( _propertyName );

                delete ptr_;
            }

            virtual void Update( RTFXObject * _object ) = 0;

            virtual bool EqualData( RTFXObject * _object )
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );

                // Assume the objects are equal to start with
                bool equal_ = true;

                if ( name.compare( _object->name ) != 0 )
                    return false;

                if ( description.compare( _object->description ) != 0 )
                    return false;

                if ( isInstance != _object->isInstance )
                    return false;

                if ( isInstance && ( instanceOfID != _object->instanceOfID ) )
                    return false;

                // Compare properties
                if ( propertyMap.size() != _object->propertyMap.size() )
                    return false;

                // Compare individual properties
                std::map<std::string, unsigned int>::iterator iter_ = propertyNameLookup.begin();
                while ( iter_ != propertyNameLookup.end() )
                {
                    RTFXProperty * ptr1_ = GetProperty( (*iter_).first );
                    RTFXProperty * ptr2_ = _object->GetProperty( (*iter_).first );

                    if ( ptr1_ == NULL || ptr2_ == NULL )
                        return false;
                    else
                        equal_ &= ptr1_->EqualTo( ptr2_ );
                }

                return equal_;
            }

            virtual void ToNative( AXISFRAME _frame ) = 0;

            virtual void FromNative( AXISFRAME _frame ) = 0;

            virtual void ChangeFrame( AXISFRAME _from, AXISFRAME _to ) = 0;

            virtual std::vector<RTFXProperty *> GetChangedProperties()
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                std::vector<RTFXProperty *> changedProperties_;

                std::map<unsigned int, RTFXProperty *>::iterator iter_ = propertyMap.begin();

                while ( iter_ != propertyMap.end() )
                {
                    RTFXProperty * ptr_ = (*iter_).second;
                    if ( ptr_->GetChanged() )
                    {
                        changedProperties_.push_back( ptr_ );
                    }
                    iter_ ++;
                }

                return changedProperties_;
            }

            virtual void SetAllPropertyChanged( bool _value )
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                std::map<unsigned int, RTFXProperty *>::iterator iter_ = propertyMap.begin();

                while ( iter_ != propertyMap.end() )
                {
                    verbose( ostringstream().flush() << "RTFXObject::SetAllPropertyChanged: property - " << (*iter_).first << endl );
                    RTFXProperty * ptr_ = (*iter_).second;
                    ptr_->SetChanged( _value );

                    iter_ ++;
                }
            }

            virtual bool ExistChangedProperties()
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                std::map<unsigned int, RTFXProperty *>::iterator iter_ = propertyMap.begin();
                while ( iter_ != propertyMap.end() )
                {
                    RTFXProperty * ptr_ = (*iter_).second;
                    if ( ptr_->GetChanged() )
                        return true;
                }
                return false;
            }

            void DeleteAllProperties()
            {
            //  boost::lock_guard<boost::mutex> lock( *dataLock );
                map<unsigned int, RTFXProperty *>::iterator iter_ = propertyMap.begin();
                while ( iter_ != propertyMap.end() )
                {
                    RTFXProperty * ptr_ = ( *iter_ ).second;
                    ++ iter_;

                    DeleteProperty( ptr_->GetID() );
                }

                // Delete the memory from the map
                {
                    map<unsigned int, RTFXProperty *> tmp_;
                    tmp_.swap( propertyMap );

                    map<string, unsigned int> tmp2_;
                    tmp2_.swap( propertyNameLookup );
                }
            }

            void SetFrame( AXISFRAME _frame ) { frame = _frame; }
            
            AXISFRAME GetFrame() { return frame; }

            void CopyProperties( const RTFXObject * _obj )
            {
                std::map<unsigned int, RTFXProperty *>::const_iterator iter_ = _obj->propertyMap.begin();
                while ( iter_ != _obj->propertyMap.end() )
                {
                    RTFXProperty * ptr_ = (*iter_).second;

                    // If property exists, udpate it
                    RTFXProperty * localProperty_ = NULL;
                    if ( PropertyExists( ptr_->GetName() ) )
                        localProperty_ = GetProperty( ptr_->GetName() );

                    if ( localProperty_ != NULL ) 
                        localProperty_->Copy( ptr_ );

                    // Otherwise, add new property
                    else
                    {
                        RTFXProperty * newPtr_;
                        RTFXProperty::RTFXPropertyData dataType_ = ptr_->GetDataType();

                        switch ( ptr_->GetType() )
                        {
                            case RTFXProperty::BASICARRAY:
                            {
                                if ( dataType_ == RTFXProperty::CHAR )
                                    newPtr_ = new RTFXPropertyArray<char>();
                                else if ( dataType_ == RTFXProperty::BOOL )
                                    newPtr_ = new RTFXPropertyArray<bool>();
                                else if ( dataType_ == RTFXProperty::DOUBLE || dataType_ == RTFXProperty::UNKNOWN )
                                    newPtr_ = new RTFXPropertyArray<double>();
                                else if ( dataType_ == RTFXProperty::FLOAT )
                                    newPtr_ = new RTFXPropertyArray<float>();
                                else if ( dataType_ == RTFXProperty::INT )
                                    newPtr_ = new RTFXPropertyArray<int>();
                                else if ( dataType_ == RTFXProperty::UNSIGNEDINT )
                                    newPtr_ = new RTFXPropertyArray<unsigned int>();
                                break;
                            }
                            case RTFXProperty::BASICTYPE:
                            {
                                if ( dataType_ == RTFXProperty::CHAR )
                                    newPtr_ = new RTFXPropertyBasic<char>();
                                else if ( dataType_ == RTFXProperty::BOOL )
                                    newPtr_ = new RTFXPropertyBasic<bool>();
                                else if ( dataType_ == RTFXProperty::DOUBLE || dataType_ == RTFXProperty::UNKNOWN )
                                    newPtr_ = new RTFXPropertyBasic<double>();
                                else if ( dataType_ == RTFXProperty::FLOAT )
                                    newPtr_ = new RTFXPropertyBasic<float>();
                                else if ( dataType_ == RTFXProperty::INT )
                                    newPtr_ = new RTFXPropertyBasic<int>();
                                else if ( dataType_ == RTFXProperty::UNSIGNEDINT )
                                    newPtr_ = new RTFXPropertyBasic<unsigned int>();
                                break;
                            }
                            case RTFXProperty::CHARARRAY:
                            {
                                newPtr_ = new RTFXPropertyCharArray();
                                break;
                            }
                            case RTFXProperty::COLOUR:
                            {
                                newPtr_ = new RTFXPropertyColour();
                                break;
                            }
                            case RTFXProperty::MATRIX4:
                            {
                                newPtr_ = new RTFXPropertyMatrix4x4();
                                break;
                            }
                            case RTFXProperty::POINT3:
                            {
                                newPtr_ = new RTFXPropertyPoint3D();
                                break;
                            }
                            case RTFXProperty::RAWDATA:
                            {
                                newPtr_ = new RTFXPropertyRawData();
                                break;
                            }
                            case RTFXProperty::STRING:
                            {
                                newPtr_ = new RTFXPropertyString();
                                break;
                            }
                            case RTFXProperty::VECTOR3:
                            {
                                newPtr_ = new RTFXPropertyVector3D();
                                break;
                            }
                            case RTFXProperty::VECTOROF:
                            {
                                if ( dataType_ == RTFXProperty::CHAR )
                                    newPtr_ = new RTFXPropertyVectorOf<char>();
                                else if ( dataType_ == RTFXProperty::BOOL )
                                    newPtr_ = new RTFXPropertyVectorOf<bool>();
                                else if ( dataType_ == RTFXProperty::DATASTRING )
                                    newPtr_ = new RTFXPropertyVectorOf<string>();
                                else if ( dataType_ == RTFXProperty::DOUBLE || dataType_ == RTFXProperty::UNKNOWN )
                                    newPtr_ = new RTFXPropertyVectorOf<double>();
                                else if ( dataType_ == RTFXProperty::FLOAT )
                                    newPtr_ = new RTFXPropertyVectorOf<float>();
                                else if ( dataType_ == RTFXProperty::INT )
                                    newPtr_ = new RTFXPropertyVectorOf<int>();
                                else if ( dataType_ == RTFXProperty::UNSIGNEDINT )
                                    newPtr_ = new RTFXPropertyVectorOf<unsigned int>();
                                break;
                            }
                            case RTFXProperty::DELETEOBJECT:
                            {
                                newPtr_ = new RTFXPropertyDeleteObject();
                                break;
                            }
                            default:
                            {
                                break;
                            }
                        }

                        if ( newPtr_ != NULL )
                        {
                            newPtr_->Copy( ptr_ );
                            AddProperty( newPtr_ );
                        }
                    }

                    iter_ ++;
                }
            }

            void SetIsInstance( bool _isInstance ) { isInstance = _isInstance; }

            bool GetIsInstance() { return isInstance; }

            void SetInstanceOfID( boost::uuids::uuid _instanceOfID ) { instanceOfID = _instanceOfID; }

            boost::uuids::uuid GetInstanceOfID() { return instanceOfID; }

            void SetNew( bool _isnew ) { isNew = _isnew; }

            bool GetIsNew() { return isNew; }

            void RemovePropertyReference( string _name )
            {
                RTFXProperty * ptr_ = NULL;
                ptr_ = GetProperty( _name );
                if ( ptr_ == NULL ) return;
                
                // Now we have a pointer to the property, must remove it from both maps
                propertyMap.erase( ptr_->GetID() );
                propertyNameLookup.erase( _name );
            }

        protected:
            unsigned int GetPropertyCount() { return nextPropertyID; }

            std::map<unsigned int, RTFXProperty *> * GetPropertyMapPointer() { return &propertyMap; }

            boost::mutex * dataLock;

            size_t ComputeTotalSize() { return sizeOfObject; }

            size_t GetSize() { return sizeOfObject; }

        private:

            size_t sizeOfObject;

            bool isNew;

            RTFXObjectType type;

            boost::uuids::uuid id;

            boost::uuids::uuid owner;

            bool hasChanged;

            bool shouldBeDeleted;

            bool shouldBeResent;

            bool isPartial;

            AXISFRAME frame;

            std::string name;

            std::string description;

            unsigned int nextPropertyID;

            std::map< unsigned int, RTFXProperty * > propertyMap;

            std::map< std::string, unsigned int > propertyNameLookup;

            bool isInstance;

            boost::uuids::uuid instanceOfID;
            
            friend class boost::serialization::access;

            template<class Archive>
            void serialize( Archive &_ar, const unsigned int _version )
            {
            //  debug( ostringstream().flush() << "RTFXObject::serialize" << endl );
                _ar & type & id & owner & hasChanged & shouldBeDeleted & shouldBeResent & isPartial & isInstance & instanceOfID & name & description;
            //  debug( ostringstream().flush() << "RTFXObject::serialize: properties" << endl );
                _ar & nextPropertyID & propertyMap & propertyNameLookup;
            //  debug( ostringstream().flush() << "RTFXObject::serialize: done." << endl );
            };
    };
}

BOOST_SERIALIZATION_ASSUME_ABSTRACT( RTFX::RTFXObject )

#endif