RList.hxx

Go to the documentation of this file.

#ifndef _RLIST_HXX_
#define _RLIST_HXX_

#include <RBasicTypes.hxx>
#include <RBase/RStatus.hxx>

// #define MALLOCTEST

namespace RayGina {
        namespace CORE {
                template<typename T> class RList {
                        public:
                                inline RList<T>() : _data(NULL),_size(0),_capacity(0) {
                                }
                
                                inline RList<T>(const RUInt newCapacity) : _size(0) {
                                        _capacity = newCapacity;
#ifdef MALLOCTEST
                                        _data = (T*)malloc(sizeof(T) * _capacity);
#else
                                        _data = new T[_capacity];
#endif
                                }
                                
/*                              inline RList<T>(const RUInt32 newCapacity,const RUInt32 increaseSize) : _size(0),_increaseSize(increaseSize) {
                                        _capacity = newCapacity;
                                        _data = new T[_capacity];
                                }
*/
                                
                                inline ~RList<T>() {
#ifdef MALLOCTEST
                                        if(NULL != _data) free(_data);
#else
                                        if(NULL != _data) delete[] _data;
#endif
                                }

                                inline T getElement(const RUInt elementNumber) const {
#ifdef RAYGINADEBUG                                     
                                        if(elementNumber >= _size) {
                                                printf("RList::getElement elementNumber=%d is bigger than size=%d\n",elementNumber,_size);
                                                exit(0);
                                        }
#endif
                                        return _data[elementNumber];
                                }
                                
                                inline const RUInt getSize() const {
                                        return _size;
                                }

                                inline const RBool isEmpty() const {
                                        return (0 == _size);
                                }

                                inline const RUInt getCapacity() const {
                                        return _capacity;
                                }

                                inline const RStatus clear() {
#ifdef MALLOCTEST
                                        if(NULL != _data) free(_data);
#else
                                        if(NULL != _data) delete[] _data;
#endif
                                        _data = NULL;
                                        _size = 0;
                                        _capacity = 0;
                                        return RStatus::SUCCESS;
                                }
                                
                                inline const RStatus setSize(const RUInt newSize) {
                                        setCapacity(newSize);
                                        _size = newSize;
                                        return RStatus::SUCCESS;
                                }

                                inline const RStatus setCapacity(const RUInt newCapacity) {
                                        // this is an easy implementation!

                                        // save the data pointer
                                        T* oldData = _data;
                                        
#ifdef MALLOCTEST
                                        _data = (T*)realloc(_data,sizeof(T) * newCapacity);
#else                                   
                                        // get new memory
                                        _data = new T[newCapacity];
#endif                                  
                                        // check for success
                                        if(NULL == _data) {
                                                
                                                // restore old data
                                                _data = oldData;
                                                
                                                // return the error
                                                printf("OY OF MEMEORY\n");
                                                return RStatus(RStatus::OUT_OF_MEMORY,"Could no allocate memory for the new RList capacity");
                                        }
                                        
                                        // set new capacity
                                        _capacity = newCapacity;

#ifdef MALLOCTEST
                                        if(_size > _capacity) _size = _capacity;
#else
                                        // if it was empty before just return, no need to copy anithing                                 
                                        if(NULL == oldData) return RStatus::SUCCESS;
                                        
                                        // copy the entries
                                        RUInt copySize = _size;                                 
                                        if(copySize > _capacity) copySize = _capacity;
                                        
                                        for(RUInt i = 0 ; i < copySize ; i++ ) {
                                                _data[i] = oldData[i];
                                        }
                                        
                                        // delete the old data
                                        delete[] oldData;
#endif                                  
                                        return RStatus::SUCCESS;
                                }

                                inline const RUInt getFreeElements() const {
                                        return  _capacity - _size;
                                }
                                
                                inline const RUInt addElement(T newElement) {
                                        
                                        if(_size == _capacity) {
                                                // increase buffer¬
                                                if(0 == _capacity) {
                                                        setCapacity(10);
                                                } else {
                                                        setCapacity(_capacity * 2);
                                                }
                                        }
                                        _data[_size] = newElement;
                                        _size++;
                                        return _size;
                                }
                                
                                inline T& operator[](const RUInt n) {
#ifdef RAYGINADEBUG
                                        if(n >= getCapacity()) {
                                                printf("\n\nBIG ERROR, RList operator[n] is called with an n(%d) bigger then capacity %d!!\nThis will lead into a crash in Release mode!\n\n",n,getCapacity());
                                                const RStatus status = setCapacity(n+1);
                                                if(RStatus::SUCCESS != status) {
//                                                      RAYGINA_LOG_ERROR(status.getMessage());
                                                        exit(0);
                                                }
                                                _size = n+1;
                                        }
#endif
                                        return _data[n];
                                }
                                
                                inline T& operator[](const RUInt n) const {
#ifdef RAYGINADEBUG
                                        if(n >= getCapacity()) {
                                                exit(0);
                                        }
#endif
                                        return _data[n];
                                }

                                inline const RStatus pack(const RUInt freeElements = 0) {
                                        return setCapacity(getSize() + freeElements);
                                }
                                
                                inline void iterate(T (*iterationFunction)(const RUInt elementNumber,T inputValue)) {
                                        // on etries => no work to do
                                        if(isEmpty()) return;
                                        
                                        for(RUInt i = 0 ; i < getSize() ; i++ ) {
                                                _data[i] = iterationFunction(i,_data[i]);                                               
                                        }
                                }
                                inline void readOnlyIterate(void (*iterationFunction)(const RUInt elementNumber,T inputValue)) {
                                        // on etries => no work to do
                                        if(isEmpty()) return;
                                        
                                        for(RUInt i = 0 ; i < getSize() ; i++ ) {
                                                iterationFunction(i,_data[i]);                                          
                                        }
                                }
                        private:
                                T*              _data;  
                                
                                RUInt   _size;
                
                                RUInt   _capacity;
                                
//                              RUInt32 _increaseSize;
                };
        };
};

#endif

---