Home

nevrax.com

Nevrax.org News Mailing-list Documentation CVS Bugs License

Documentation                       Search   ps_attrib.h Go to the documentation of this file. /* Copyright, 2001 Nevrax Ltd. * * This file is part of NEVRAX NEL. * NEVRAX NEL is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * NEVRAX NEL is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * You should have received a copy of the GNU General Public License * along with NEVRAX NEL; see the file COPYING. If not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, * MA 02111-1307, USA. */ #ifndef NL_PS_ATTRIB_H #define NL_PS_ATTRIB_H #include "nel/misc/types_nl.h" #include "nel/misc/stream.h" #include "nel/3d/animation_time.h" #include "nel/misc/vector.h" #include "nel/misc/rgba.h" #include "nel/misc/common.h" namespace NL3D { template <class T, const uint snapPower = 5> class CSnappedVector { public: typedef T *iterator; typedef const T *const_iterator; typedef T value_type; CSnappedVector() : _Size(0), _Capacity(0), _Start(NULL), _Tab(NULL) {} ~CSnappedVector() { nlassert(_Size <= _Capacity); for (iterator it = _Tab, endIt = _Tab + _Size; it != endIt; ++it) { it->~T(); } delete _Start; } iterator begin(void) { return _Tab; } const_iterator begin(void) const { return _Tab; } iterator end(void) { return _Tab + _Size; } const_iterator end(void) const { return _Tab + _Size; } T &operator[](uint index) { nlassert(index < _Size && _Size); return _Tab[index]; } const T &operator[](uint index) const { nlassert(index < _Size && _Size); return _Tab[index]; } void reserve(uint capacity) { if (capacity < _Capacity) return; uint8 *newStart = NULL; try { newStart = new uint8[sizeof(T) * capacity + (1 << snapPower)]; T *newTab = (T *) ( (uint) (newStart + (1 << snapPower)) & ~((1 << snapPower) - 1)); // snap to a page for (iterator src = _Tab, end = _Tab + (capacity < _Size ? capacity : _Size), dest = newTab ; src != end ; ++ src, ++dest) { new ((void *) dest) T(*src); // copy object } // swap datas std::swap(_Start, newStart); std::swap(_Tab, newTab); // destroy previous objects. We assume that we can't have exceptions raised from destructors for (iterator it = newTab /* old tab */, endIt = newTab + _Size; it != endIt; ++ it) { it->~T(); } // set new size _Capacity = capacity; _Size = capacity < _Size ? capacity : _Size; // delete old vect (that was swapped with the new one) delete [] newStart; nlassert(_Size <= _Capacity); } catch (...) { delete [] newStart; throw; } } void resize(uint size) { nlassert(size < (1 << 16)); if (size < _Size) { for (iterator it = _Tab + size, endIt = _Tab + _Size; it != endIt; ++it) { it->~T(); } } else { if (size > _Capacity) { reserve(size); } for (iterator it = _Tab + _Size, endIt = _Tab + size; it != endIt; ++it) { new ((void *) it) T(); } } _Size = size; nlassert(_Size <= _Capacity); } void push_back(const T &t) { if (!_Size) { reserve(2); new ((void *) _Tab) T(t); _Size = 1; } else if (_Size < _Capacity) { new ((void *) (_Tab + _Size)) T(t); ++_Size; } else if (_Size == _Capacity) { if (_Capacity == 1) { reserve(2); } else { reserve(_Capacity + (_Capacity>>1)); } nlassert(_Size <= _Capacity); new ((void *) (_Tab + _Size)) T(t); ++_Size; } } void pop_back() { nlassert(_Size); _Tab[_Size - 1].~T(); --_Size; } uint capacity() const { return _Capacity; } uint size() const { return _Size; } void serial(NLMISC::IStream &f) throw(NLMISC::EStream) { if (f.isReading()) { clear(); uint32 size, maxsize; f.serial(size, maxsize); reserve(maxsize); for (uint k = 0; k < size; ++k) { T tmp; f.serial(tmp); push_back(tmp); } } else { f.serial(_Size, _Capacity); for (uint k = 0; k < _Size; ++k) { f.serial(_Tab[k]); } } } // clear void clear() { resize(0); } protected: uint8 *_Start; // real allocation address T *_Tab; // first element uint32 _Size; // used elements uint32 _Capacity; // max size }; template <typename T> class CPSAttrib { public: CPSAttrib(); void serial(NLMISC::IStream &f) throw(NLMISC::EStream); //typedef CSnappedVector<T> TContType; typedef std::vector<T> TContType; typedef T value_type; typedef typename TContType::iterator iterator; typedef typename TContType::const_iterator const_iterator; void resize(uint32 nbInstances); uint32 getSize(void) const { return _Tab.size(); } uint32 getMaxSize(void) const { return _MaxSize; } const T & operator[](uint32 index) const { #ifdef NL_DEBUG nlassert(index < _Tab.size()); #endif return _Tab[index]; } T & operator[](uint32 index) { #ifdef NL_DEBUG nlassert(index < _Tab.size()); #endif return _Tab[index]; } iterator begin(void) { return _Tab.begin(); } iterator end(void) { return _Tab.end(); } const_iterator begin(void) const { return _Tab.begin(); } const_iterator end(void) const { return _Tab.end(); } sint32 insert(const T &t = T() ); void remove(uint32 index); void clear(void) { _Tab.clear(); } protected: TContType _Tab; uint32 _MaxSize; // the max number of elements that can be stored }; // IMPLEMENTATION // template <typename T> CPSAttrib<T>::CPSAttrib() { _MaxSize = DefaultMaxLocatedInstance; } template <typename T> void CPSAttrib<T>::resize(uint32 nbInstances) { nlassert(nbInstances < (1 << 16)); _Tab.reserve(nbInstances); _MaxSize = nbInstances; } template <typename T> sint32 CPSAttrib<T>::insert(const T &t) { if (_Tab.size() == _MaxSize && _Tab.size() > DefaultMaxLocatedInstance) { return -1; } _Tab.push_back(t); return _Tab.size() - 1; } template <typename T> void CPSAttrib<T>::remove(uint32 index) { nlassert(index < _Tab.size()); // we copy the last element in place of this one if (index != _Tab.size() - 1) { _Tab[index] = _Tab[_Tab.size() - 1]; } _Tab.pop_back(); } template <typename T> void CPSAttrib<T>::serial(NLMISC::IStream &f) throw(NLMISC::EStream) { sint ver = f.serialVersion(3); // in the first version, size was duplicated, we were using a std::vector ... if (ver == 1) { if(f.isReading()) { uint32 size; f.serial(size); f.serial(_MaxSize); _Tab.reserve(_MaxSize); f.serial(size); // useless but, we were previously doing a serialCont... compatibility purpose only T tmp; // Read the vector for(uint i = 0; i < size; i++) { f.serial(tmp); _Tab.push_back(tmp); } nlassert(_Tab.size() == size); } else { uint32 size = _Tab.size(); f.serial(size); f.serial(_MaxSize); f.serial(size); // write the vector for(uint i = 0; i < size; i++) { f.serial(_Tab[i]); } } } if (ver == 2) // this version didn't work well, it relied on the capacity of the container to store the max number of instances { nlassert(0); /* f.serial(_Tab); if (f.isReading()) { _MaxSize = _Tab.capacity(); }*/ } if (ver == 3) { f.serial(_MaxSize); _Tab.reserve(_MaxSize); //f.serial(_Tab); if (f.isReading()) { _Tab.clear(); uint32 size, maxsize; f.serial(size, maxsize); _Tab.reserve(maxsize); for (uint k = 0; k < size; ++k) { T tmp; f.serial(tmp); _Tab.push_back(tmp); } } else { uint32 size = _Tab.size(), capacity = _Tab.capacity(); f.serial(size, capacity); for (uint k = 0; k < size; ++k) { f.serial(_Tab[k]); } } } } // here we give some definition for common types typedef CPSAttrib<NLMISC::CVector> TPSAttribVector; typedef CPSAttrib<NLMISC::CRGBA> TPSAttribRGBA; typedef CPSAttrib<float> TPSAttribFloat; typedef CPSAttrib<uint32> TPSAttribUInt; typedef CPSAttrib<uint8> TPSAttribUInt8; typedef CPSAttrib<TAnimationTime> TPSAttribTime; } // NL3D #endif // NL_PS_ATTRIB_H /* End of ps_attrib.h */