RTFXPropertyArray.h

Go to the documentation of this file.

#ifndef __RTFX_PROPERTY_ARRAY__
#define __RTFX_PROPERTY_ARRAY__



#include "RTFXBoostIncludes.h"

#include "RTFXMath.h"
#include "RTFXRecorder.h"
#include "RTFXHelpers.h"
#include "RTFXProperty.h"

using namespace std;

namespace RTFX
{
    template<class T>
    class RTFXAPI RTFXPropertyArray: public RTFXProperty
    {
        public:
            RTFXPropertyArray() 
            { 
                SetType( RTFXProperty::BASICARRAY );
                value = NULL; 
                length = 0;
            }

            ~RTFXPropertyArray() 
            { 
                free( value );
                value = NULL;
                length = 0;
            }

            void Copy( RTFXProperty * _p )
            {
                SetID( _p->GetID() );
                SetName( _p->GetName() );
                SetDescription( _p->GetDescription() );
                SetOwner( _p->GetOwner() );
                SetChanged( _p->GetChanged() );
                SetType( _p->GetType() );
                SetDelete( _p->GetDelete() );

                RTFXPropertyArray<T> * ptr_ = ( RTFXPropertyArray<T> * )_p;
                SetValue( ptr_->GetValue(), ptr_->GetLength() );
            }

            void SetValue( T * _value, RTFXBIGINT _length ) 
            { 
                boost::lock_guard<boost::mutex> lock( *dataLock );

                // If the current value is not null, then we must free the existing memory
                if ( value == NULL )
                    free( value );

                // allocate memory for this value
                value = ( T * )malloc( _length * sizeof( T ) );

                // copy the data into it
                memcpy( value, _value, _length * sizeof( T ) );

                // set length value
                length = _length;

                SetChanged( true );         
            }

            void SetValue( T * _value, RTFXBIGINT _start, RTFXBIGINT _end )
            {
                boost::lock_guard<boost::mutex> lock( *dataLock );

                T * newdata_ = value;
                if ( _end > length )
                {
                    free( value );

                    newdata_ = ( T * )malloc( _end * sizeof( T ) );
                    memcpy( newdata_, _value, length * sizeof( T ) );
                    value = newdata_;
                }

                for ( RTFXBIGINT i = 0; i < _end - _start; i ++ )
                {
                    value[_start+i] = _value[i];
                }   
                
                SetChanged( true );
            }

            T * GetValue() 
            { 
                boost::lock_guard<boost::mutex> lock( *dataLock );

                SetChanged( false );

                return value;
            }

            T GetValueAt( RTFXBIGINT _index )
            {
                boost::lock_guard<boost::mutex> lock( *dataLock );
                SetChanged( false );
                if ( _index >= length )
                {
                    
                    return 0;
                }
                else
                {
                    T v_ = value[ _index ];
                    
                    return v_;
                }
            }
            
            void SetValueAt( T _value, RTFXBIGINT _index )
            {
                if ( _index >= length )
                    return;
                else
                    value[ _index ] = _value;
                
                SetChanged( true );
            }

            RTFXBIGINT GetLength() { return length; }

            bool EqualTo( RTFXProperty * _other )
            {
                // Check if Property types match (just in case)
                if ( GetType() == _other->GetType() )
                {
                    if ( memcmp( value, (( RTFXPropertyArray * )_other)->value, length ) == 0 )
                        return true;
                }
                return false;
            }

        private:

            T * value;

            RTFXBIGINT length;

            friend class boost::serialization::access;

            template<class Archive>
            void save( Archive &_ar, const unsigned int _version ) const
            {
                _ar << boost::serialization::base_object<RTFXProperty>( *this );

                /*(char * tmp_ = new char[sizeof( RTFXBIGINT )];
                EncodeLong( length, tmp_ );
                for ( unsigned int i = 0; i < sizeof( RTFXBIGINT ); i ++ )
                    _ar << tmp_[i];*/
                _ar << length;
                
                for ( unsigned int i = 0; i < length; i ++ )
                {
                    //if ( i % 100000 == 0 )
                    //  debug( ostringstream().flush() << "RTFXPropertyArray<T>::save: serializing ... " << i << endl );
                    _ar << value[i];
                }
            }

            template<class Archive>
            void load( Archive &_ar, const unsigned int _version )
            {
                _ar >> boost::serialization::base_object<RTFXProperty>( *this );

                /*char * tmp_ = new char[sizeof( RTFXBIGINT )];
                for ( unsigned int i = 0; i < sizeof( RTFXBIGINT ); i ++ )
                    _ar >> tmp_[i];

                DecodeLong( length, tmp_ );*/
                _ar >> length;

                value = ( T * ) malloc( length * sizeof( T ) );

                for ( unsigned int i = 0; i < length; i ++ )
                    _ar >> value[i];
            }

            template<class Archive>
            void serialize( Archive &_ar, const unsigned int _version )
            {
                boost::serialization::split_member( _ar, (*this), _version );
            }
    //      BOOST_SERIALIZATION_SPLIT_MEMBER()
    };
}

BOOST_CLASS_EXPORT_KEY( RTFX::RTFXPropertyArray<unsigned int> )
BOOST_CLASS_EXPORT_KEY( RTFX::RTFXPropertyArray<int> )
BOOST_CLASS_EXPORT_KEY( RTFX::RTFXPropertyArray<float> )
BOOST_CLASS_EXPORT_KEY( RTFX::RTFXPropertyArray<double> )
BOOST_CLASS_EXPORT_KEY( RTFX::RTFXPropertyArray<bool> )
BOOST_CLASS_EXPORT_KEY( RTFX::RTFXPropertyArray<char> )

#endif