00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00021
00022
00023 #ifndef H_SPK_POOL
00024 #define H_SPK_POOL
00025
00026 #include "Core/SPK_DEF.h"
00027
00028
00029 namespace SPK
00030 {
00051 template<class T>
00052 class Pool
00053 {
00054 public :
00055
00057 typedef typename std::vector<T>::iterator iterator;
00058
00060 typedef typename std::vector<T>::const_iterator const_iterator;
00061
00063 typedef typename std::vector<T>::reverse_iterator reverse_iterator;
00064
00066 typedef typename std::vector<T>::const_reverse_iterator const_reverse_iterator;
00067
00069 static const unsigned int DEFAULT_CAPACITY = 1000;
00070
00072
00074
00085 Pool<T>(size_t capacity = DEFAULT_CAPACITY);
00086
00087 Pool<T>(const Pool<T>& pool);
00088
00090
00092
00093 Pool<T>& operator=(const Pool<T>& pool);
00094
00103 T& operator[](size_t index);
00104
00113 const T& operator[](size_t index) const;
00114
00116
00118
00127 size_t size() const;
00128
00136 size_t getNbActive() const;
00137
00142 size_t getNbInactive() const;
00143
00151 size_t getNbTotal() const;
00152
00160 size_t getNbReserved() const;
00161
00169 size_t getNbEmpty() const;
00170
00178 size_t getMaxTotal() const;
00179
00181
00183
00191 iterator begin();
00192
00201 iterator end();
00202
00210 iterator beginActive();
00211
00220 iterator endActive();
00221
00229 iterator beginInactive();
00230
00235 iterator endInactive();
00236
00244 const_iterator begin() const;
00245
00253 const_iterator end() const;
00254
00262 const_iterator beginActive() const;
00263
00271 const_iterator endActive() const;
00272
00280 const_iterator beginInactive() const;
00281
00289 const_iterator endInactive() const;
00290
00298 reverse_iterator rbegin();
00299
00308 reverse_iterator rend();
00309
00317 reverse_iterator rbeginActive();
00318
00327 reverse_iterator rendActive();
00328
00336 reverse_iterator rbeginInactive();
00337
00342 reverse_iterator rendInactive();
00343
00351 const_reverse_iterator rbegin() const;
00352
00360 const_reverse_iterator rend() const;
00361
00369 const_reverse_iterator rbeginActive() const;
00370
00378 const_reverse_iterator rendActive() const;
00379
00387 const_reverse_iterator rbeginInactive() const;
00388
00396 const_reverse_iterator rendInactive() const;
00397
00399
00401
00410 T& front();
00411
00420 T& back();
00421
00430 T& frontActive();
00431
00440 T& backActive();
00441
00447 T& frontInactive();
00448
00454 T& backInactive();
00455
00464 const T& front() const;
00465
00474 const T& back() const;
00475
00484 const T& frontActive() const;
00485
00494 const T& backActive() const;
00495
00504 const T& frontInactive() const;
00505
00514 const T& backInactive() const;
00515
00516
00518
00520
00529 void assign(T& value);
00530
00536 bool pushActive(T& element);
00537
00543 bool pushInactive(T& element);
00544
00552 void makeInactive(size_t index);
00553
00555 void makeAllInactive();
00556
00565 T* makeActive();
00566
00578 T* makeActive(size_t index);
00579
00589 void erase(size_t index);
00590
00592 void clear();
00593
00602 void reallocate(size_t capacity);
00603
00604 private :
00605
00606 std::vector<T> container;
00607
00608 size_t nbActive;
00609 size_t maxTotal;
00610
00611 void swapElements(T& a,T& b);
00612 };
00613
00614
00615 template<class T>
00616 Pool<T>::Pool(size_t capacity) :
00617 nbActive(0),
00618 maxTotal(0)
00619 {
00620 container.reserve(capacity);
00621 }
00622
00623 template<class T>
00624 Pool<T>::Pool(const Pool<T>& pool) :
00625 nbActive(pool.nbActive),
00626 maxTotal(0),
00627 container()
00628 {
00629
00630 container.reserve(pool.container.capacity());
00631 container = pool.container;
00632 }
00633
00634 template<class T>
00635 Pool<T>& Pool<T>::operator=(const Pool<T>& pool)
00636 {
00637 if (this != &pool)
00638 {
00639 nbActive = pool.nbActive();
00640 maxTotal = 0;
00641 container.reserve(pool.container.capacity());
00642 container = pool.container;
00643 }
00644 return *this;
00645 }
00646
00647 template<class T>
00648 T& Pool<T>::operator[](size_t index)
00649 {
00650 return container[index];
00651 }
00652
00653 template<class T>
00654 const T& Pool<T>::operator[](size_t index) const
00655 {
00656 return container[index];
00657 }
00658
00659 template<class T>
00660 inline size_t Pool<T>::size() const
00661 {
00662 return nbActive;
00663 }
00664
00665 template<class T>
00666 inline size_t Pool<T>::getNbActive() const
00667 {
00668 return nbActive;
00669 }
00670
00671 template<class T>
00672 inline size_t Pool<T>::getNbInactive() const
00673 {
00674 return container.size() - nbActive;
00675 }
00676
00677 template<class T>
00678 inline size_t Pool<T>::getNbTotal() const
00679 {
00680 return container.size();
00681 }
00682
00683 template<class T>
00684 inline size_t Pool<T>::getNbReserved() const
00685 {
00686 return container.capacity();
00687 }
00688
00689 template<class T>
00690 inline size_t Pool<T>::getNbEmpty() const
00691 {
00692 return container.capacity() - container.size();
00693 }
00694
00695 template<class T>
00696 inline size_t Pool<T>::getMaxTotal() const
00697 {
00698 return maxTotal;
00699 }
00700
00701 template<class T>
00702 inline typename Pool<T>::iterator Pool<T>::begin()
00703 {
00704 return container.begin();
00705 }
00706
00707 template<class T>
00708 inline typename Pool<T>::iterator Pool<T>::end()
00709 {
00710 return container.begin() + nbActive;
00711 }
00712
00713 template<class T>
00714 inline typename Pool<T>::iterator Pool<T>::beginActive()
00715 {
00716 return begin();
00717 }
00718
00719 template<class T>
00720 inline typename Pool<T>::iterator Pool<T>::endActive()
00721 {
00722 return end();
00723 }
00724
00725 template<class T>
00726 inline typename Pool<T>::iterator Pool<T>::beginInactive()
00727 {
00728 return end();
00729 }
00730
00731 template<class T>
00732 inline typename Pool<T>::iterator Pool<T>::endInactive()
00733 {
00734 return container.end();
00735 }
00736
00737 template<class T>
00738 inline typename Pool<T>::const_iterator Pool<T>::begin() const
00739 {
00740 return container.begin();
00741 }
00742
00743 template<class T>
00744 inline typename Pool<T>::const_iterator Pool<T>::end() const
00745 {
00746 return container.begin() + nbActive;
00747 }
00748
00749 template<class T>
00750 inline typename Pool<T>::const_iterator Pool<T>::beginActive() const
00751 {
00752 return begin();
00753 }
00754
00755 template<class T>
00756 inline typename Pool<T>::const_iterator Pool<T>::endActive() const
00757 {
00758 return end();
00759 }
00760
00761 template<class T>
00762 inline typename Pool<T>::const_iterator Pool<T>::beginInactive() const
00763 {
00764 return end();
00765 }
00766
00767 template<class T>
00768 inline typename Pool<T>::const_iterator Pool<T>::endInactive() const
00769 {
00770 return container.end();
00771 }
00772
00773 template<class T>
00774 inline typename Pool<T>::reverse_iterator Pool<T>::rbegin()
00775 {
00776 return container.rbegin();
00777 }
00778
00779 template<class T>
00780 inline typename Pool<T>::reverse_iterator Pool<T>::rend()
00781 {
00782 return container.rbegin() + nbActive;
00783 }
00784
00785 template<class T>
00786 inline typename Pool<T>::reverse_iterator Pool<T>::rbeginActive()
00787 {
00788 return rbegin();
00789 }
00790
00791 template<class T>
00792 inline typename Pool<T>::reverse_iterator Pool<T>::rendActive()
00793 {
00794 return rend();
00795 }
00796
00797 template<class T>
00798 inline typename Pool<T>::reverse_iterator Pool<T>::rbeginInactive()
00799 {
00800 return rend();
00801 }
00802
00803 template<class T>
00804 inline typename Pool<T>::reverse_iterator Pool<T>::rendInactive()
00805 {
00806 return container.rend();
00807 }
00808
00809 template<class T>
00810 inline typename Pool<T>::const_reverse_iterator Pool<T>::rbegin() const
00811 {
00812 return container.rbegin();
00813 }
00814
00815 template<class T>
00816 inline typename Pool<T>::const_reverse_iterator Pool<T>::rend() const
00817 {
00818 return container.rbegin() + nbActive;
00819 }
00820
00821 template<class T>
00822 inline typename Pool<T>::const_reverse_iterator Pool<T>::rbeginActive() const
00823 {
00824 return rbegin();
00825 }
00826
00827 template<class T>
00828 inline typename Pool<T>::const_reverse_iterator Pool<T>::rendActive() const
00829 {
00830 return rend();
00831 }
00832
00833 template<class T>
00834 inline typename Pool<T>::const_reverse_iterator Pool<T>::rbeginInactive() const
00835 {
00836 return rend();
00837 }
00838
00839 template<class T>
00840 inline typename Pool<T>::const_reverse_iterator Pool<T>::rendInactive() const
00841 {
00842 return container.rend();
00843 }
00844
00845 template<class T>
00846 inline T& Pool<T>::front()
00847 {
00848 return container.front();
00849 }
00850
00851 template<class T>
00852 inline T& Pool<T>::back()
00853 {
00854 return container[nbActive - 1];
00855 }
00856
00857 template<class T>
00858 inline T& Pool<T>::frontActive()
00859 {
00860 return front();
00861 }
00862
00863 template<class T>
00864 inline T& Pool<T>::backActive()
00865 {
00866 return back();
00867 }
00868
00869 template<class T>
00870 inline T& Pool<T>::frontInactive()
00871 {
00872 return container[nbActive];
00873 }
00874
00875 template<class T>
00876 inline T& Pool<T>::backInactive()
00877 {
00878 return container.back();
00879 }
00880
00881 template<class T>
00882 inline const T& Pool<T>::front() const
00883 {
00884 return container.front();
00885 }
00886
00887 template<class T>
00888 inline const T& Pool<T>::back() const
00889 {
00890 return container[nbActive - 1];
00891 }
00892
00893 template<class T>
00894 inline const T& Pool<T>::frontActive() const
00895 {
00896 return front();
00897 }
00898
00899 template<class T>
00900 inline const T& Pool<T>::backActive() const
00901 {
00902 return back();
00903 }
00904
00905 template<class T>
00906 inline const T& Pool<T>::frontInactive() const
00907 {
00908 return container[nbActive];
00909 }
00910
00911 template<class T>
00912 inline const T& Pool<T>::backInactive() const
00913 {
00914 return container.back();
00915 }
00916
00917 template<class T>
00918 inline void Pool<T>::assign(T& value)
00919 {
00920 container.insert(container.end(),getNbEmpty(),value);
00921 }
00922
00923 template<class T>
00924 inline void Pool<T>::swapElements(T& a,T& b)
00925 {
00926 std::swap(a,b);
00927 }
00928
00929 template<class T>
00930 bool Pool<T>::pushActive(T& element)
00931 {
00932 if (container.size() == container.capacity())
00933 return false;
00934
00935 container.push_back(element);
00936 swapElements(container[nbActive],container.back());
00937 ++nbActive;
00938
00939 if (container.size() > maxTotal)
00940 maxTotal = container.size();
00941
00942 return true;
00943 }
00944
00945 template<class T>
00946 bool Pool<T>::pushInactive(T& element)
00947 {
00948 if (container.size() == container.capacity())
00949 return false;
00950
00951 container.push_back(element);
00952
00953 if (container.size() > maxTotal)
00954 maxTotal = container.size();
00955
00956 return true;
00957 }
00958
00959 template<class T>
00960 void Pool<T>::makeInactive(size_t index)
00961 {
00962 if (index >= nbActive)
00963 return;
00964
00965 swapElements(container[index],container[nbActive - 1]);
00966 --nbActive;
00967 }
00968
00969 template<class T>
00970 inline void Pool<T>::makeAllInactive()
00971 {
00972 nbActive = 0;
00973 }
00974
00975 template<class T>
00976 T* Pool<T>::makeActive()
00977 {
00978 if (getNbInactive() == 0)
00979 return NULL;
00980
00981 ++nbActive;
00982 return &container[0] + nbActive - 1;
00983 }
00984
00985 template<class T>
00986 T* Pool<T>::makeActive(size_t index)
00987 {
00988 if (getNbInactive() < index)
00989 return NULL;
00990
00991 swapElements(container[nbActive],container[nbActive + index]);
00992 ++nbActive;
00993 return &container[0] + nbActive - 1;
00994 }
00995
00996 template<class T>
00997 void Pool<T>::erase(size_t index)
00998 {
00999 if (index >= container.size())
01000 return;
01001
01002 if (index < nbActive)
01003 {
01004 swapElements(container[index],container[nbActive - 1]);
01005 --nbActive;
01006 index = nbActive;
01007 }
01008
01009 swapElements(container[index],container.back());
01010 container.pop_back();
01011 }
01012
01013 template<class T>
01014 void Pool<T>::clear()
01015 {
01016 container.clear();
01017 nbActive = 0;
01018 }
01019
01020 template<class T>
01021 inline void Pool<T>::reallocate(size_t capacity)
01022 {
01023 container.reserve(capacity);
01024 }
01025 }
01026
01027 #endif