daeArray.h

Go to the documentation of this file.

/*
* Copyright 2006 Sony Computer Entertainment Inc.
*
* Licensed under the MIT Open Source License, for details please see license.txt or the website
* http://www.opensource.org/licenses/mit-license.php
*
*/ 

#ifndef __DAE_ARRAY_H__
#define __DAE_ARRAY_H__
#include <new>
#include <dae/daeMemorySystem.h>

class daeAtomicType;

class daeArray
{
protected:
        size_t         _count;
        size_t         _capacity;
        daeMemoryRef   _data;
        size_t         _elementSize;
        daeAtomicType* _type;
public:
        DLLSPEC daeArray();
        virtual DLLSPEC ~daeArray();
        virtual DLLSPEC void clear() = 0;
        DLLSPEC void setElementSize(size_t elementSize);
        size_t getElementSize() const {return _elementSize;}
        virtual void setCount(size_t cnt) = 0;
        size_t getCount() const {return _count;}
        virtual void grow(size_t minCapacity) = 0;
        size_t getCapacity() const {return _capacity;}
        daeMemoryRef getRaw(size_t index) const {return _data + index*_elementSize;}
        virtual daeInt removeIndex(size_t index) = 0;

        // Provided for backward compatibility only. Don't use these.
        void setRawCount(size_t cnt) { setCount(cnt); } // Use setCount instead
        daeMemoryRef getRawData() const {return _data;} // Use getRaw instead
};

template <class T>
class daeTArray : public daeArray
{
protected:
        T* prototype;
public:
        daeTArray() {
                _elementSize = sizeof( T );
                prototype = NULL;
        }
        explicit daeTArray(T* prototype) : prototype(prototype) {
                _elementSize = sizeof( T );
        }
        daeTArray( const daeTArray<T> &cpy ) : daeArray() {
                prototype = NULL;
                *this = cpy;
        }
        explicit daeTArray( const T &el ) {
                _elementSize = sizeof(T);
                prototype = NULL;
                append( el );
        }
        virtual ~daeTArray() {
                clear();
                delete prototype;
        }
        virtual void clear()
        {
                for(size_t i=0;i<_count;i++)
                        ((T*)_data + i)->~T();
                free(_data);
                _count = 0;
                _capacity = 0;
                _data = NULL;
        }
        
        void grow(size_t minCapacity) {
                if (minCapacity <= _capacity)
                        return;

                size_t newCapacity = _capacity == 0 ? 1 : _capacity;
                while(newCapacity < minCapacity)
                        newCapacity *= 2;
        
                T* newData = (T*)malloc(newCapacity*_elementSize);
                for (size_t i = 0; i < _count; i++) {
                        new (&newData[i]) T(get(i));
                        ((T*)_data + i)->~T();
                }
        
                if (_data != NULL)
                        free(_data);
        
                _data = (daeMemoryRef)newData;
                _capacity = newCapacity;
        }

        virtual daeInt removeIndex(size_t index)
        {
                if (index >= _count)
                        return(DAE_ERR_INVALID_CALL);

                for (size_t i = index; i < _count-1; i++)
                        *((T*)_data+i) = *((T*)_data+i+1);
                ((T*)_data+(_count-1))->~T();
                _count--;
                return DAE_OK;
        }

        void setCount(size_t nElements, const T& value)
        {
                grow(nElements);
                // Destruct the elements that are being chopped off
                for (size_t i = nElements; i < _count; i++)
                        ((T*)_data+i)->~T();
                // Use value to initialize the new elements
                for (size_t i = _count; i < nElements; i++)
                        new ((void*)((T*)_data+i)) T(value);
                _count = nElements;
        }

        virtual void setCount(size_t nElements) {
                if (prototype)
                        setCount(nElements, *prototype);
                else
                        setCount(nElements, T());
        }
        
        void set(size_t index, const T& value) {
                if (index >= _count)
                        setCount(index+1);
                ((T*)_data)[index] = value;
        }
        
        T& get(size_t index) {
                assert(index < _count);
                return ((T*)_data)[index]; }
        const T& get(size_t index) const {
                assert(index < _count);
                return ((T*)_data)[index]; }
        
        size_t append(const T& value) {
                set(_count, value);
                return _count-1;
        }

        size_t appendUnique(const T& value) {
                size_t ret;
                if (find(value,ret) != DAE_OK)
                        return append(value);
                else 
                        return ret;
        }

        void prepend(const T& value) {
                insertAt(0, value);
        }
        
        daeInt remove(const T& value, size_t *idx = NULL ) 
        {
                size_t index;
                if(find(value,index) == DAE_OK)
                {
                        if ( idx != NULL ) {
                                *idx = index;
                        }
                        return(removeIndex( index ));
                }
                else
                {
                        return(DAE_ERR_INVALID_CALL);
                }
        }
        daeInt find(const T& value, size_t &index) const 
        {
                size_t i;
                for(i=0;i<_count;i++)
                {
                        if (((T*)_data)[i] == value)
                        {
                                index = i;
                                return DAE_OK;
                        }
                }

                return DAE_ERR_QUERY_NO_MATCH;
        }
        T* find(const T& value) const {
                size_t i;
                if (find(value, i) == DAE_OK)
                        return get(i);
                return NULL;
        }
        T& operator[](size_t index) {
                assert(index < _count);
                return ((T*)_data)[index]; }
        const T& operator[](size_t index) const {
                assert(index < _count);
                return ((T*)_data)[index]; }
        
        void insert(size_t index, size_t n, const T& val = T()) {
                if (index >= _count) {
                        // Append to the end of the array
                        size_t oldCount = _count;
                        setCount(index + n); 
                        for (size_t i = oldCount; i < _count; i++)
                                get(i) = val;
                }
                else {
                        setCount(_count + n);
                        for (size_t i = _count-1; i >= index+n; i--)
                                get(i) = get(i-n);
                        for (size_t i = index; i < index+n; i++)
                                get(i) = val;
                }
        }

        void insertAt(size_t index, const T& value) {
                insert(index, 1);
                get(index) = value;
        }

        daeTArray<T> &operator=( const daeTArray<T> &other ) {
                if (this != &other) {
                        clear();
                        _elementSize = other._elementSize;
                        _type = other._type;
                        grow(other._count);
                        for(size_t i=0;i<other._count;i++)
                                append(other[i]);
                }

                return *this;
        }

        bool operator==(const daeTArray<T>& other) {
                if (getCount() != other.getCount())
                        return false;
                for (size_t i = 0; i < getCount(); i++)
                        if (get(i) != other.get(i))
                                return false;
                return true;
        }

        //some helpers
        void set2( const T &one, const T &two )
        {
                setCount( 2 );
                set( 0, one );
                set( 1, two );
        }
        void set3( const T &one, const T &two, const T &three )
        {
                setCount( 3 );
                set( 0, one );
                set( 1, two );
                set( 2, three );
        }
        void set4( const T &one, const T &two, const T &three, const T &four )
        {
                setCount( 4 );
                set( 0, one );
                set( 1, two );
                set( 2, three );
                set( 3, four );
        }

        void set2at( size_t index, const T &one, const T &two )
        {
                set( index, one );
                set( index+1, two );
        }
        void set3at( size_t index, const T &one, const T &two, const T &three )
        {
                set( index, one );
                set( index+1, two );
                set( index+2, three );
        }
        void set4at( size_t index, const T &one, const T &two, const T &three, const T &four )
        {
                set( index, one );
                set( index+1, two );
                set( index+2, three );
                set( index+3, four );
        }

        void append2( const T &one, const T &two )
        {
                append( one );
                append( two );
        }
        void append3( const T &one, const T &two, const T &three )
        {
                append( one );
                append( two );
                append( three );
        }
        void append4( const T &one, const T &two, const T &three, const T &four )
        {
                append( one );
                append( two );
                append( three );
                append( four );
        }

        void insert2at( size_t index, const T &one, const T &two )
        {
                insert(index, 2);
                set(index, one);
                set(index+1, two);
        }
        void insert3at( size_t index, const T &one, const T &two, const T &three )
        {
                insert(index, 3);
                set( index, one );
                set( index+1, two );
                set( index+2, three );
        }
        void insert4at( size_t index, const T &one, const T &two, const T &three, const T &four )
        {
                insert(index, 4);
                set( index, one );
                set( index+1, two );
                set( index+2, three );
                set( index+4, four );
        }

        daeInt get2at( size_t index, T &one, T &two )
        {
                daeInt retVal = 0;
                if ( index < _count )
                {
                        one = get(index);
                        retVal++;
                }
                if ( index+1 < _count )
                {
                        two = get(index+1);
                        retVal++;
                }
                return retVal;
        } 
        daeInt get3at( size_t index, T &one, T &two, T &three )
        {
                daeInt retVal = 0;
                if ( index < _count )
                {
                        one = get(index);
                        retVal++;
                }
                if ( index+1 < _count )
                {
                        two = get(index+1);
                        retVal++;
                }
                if ( index+2 < _count )
                {
                        three = get(index+2);
                        retVal++;
                }
                return retVal;
        }
        daeInt get4at( size_t index, T &one, T &two, T &three, T &four )
        {
                daeInt retVal = 0;
                if ( index < _count )
                {
                        one = get(index);
                        retVal++;
                }
                if ( index+1 < _count )
                {
                        two = get(index+1);
                        retVal++;
                }
                if ( index+2 < _count )
                {
                        three = get(index+2);
                        retVal++;
                }
                if ( index+3 < _count )
                {
                        four = get(index+3);
                        retVal++;
                }
                return retVal;
        }

        void appendArray( size_t num, T *array )
        {
                if ( array == NULL )
                        return;

                for ( size_t i = 0; i < num; i++ )
                        append( array[i] );
        }
        void appendArray( const daeTArray<T> &array ){
                size_t num = array.getCount();
                for ( size_t i = 0; i < num; i++ )
                        append( array[i] );
        }
};


#endif //__DAE_ARRAY_H__

---

colladadom
Author(s): Du Hung Hou, Khronos.org, Marcus Barnes, Greg Corson, Herbert Law, Sebastian Schwarz, Steven Thomas, John Hsu (ros package), Tim Field (ros package)
autogenerated on Fri Jan 11 09:24:25 2013