CSAutoSkipList.h

Go to the documentation of this file.
00001 
00009 
00010 
00057 template <class T, class Pr = std::less<T>, class R = RNG >
00058 class AutoSkipList
00059 {
00060 public:
00061   class T0;
00062   class T1;
00063   friend class T0;
00064   friend class T1;
00066   typedef size_t size_type;
00068 
00071   typedef ptrdiff_t difference_type;
00073   typedef T value_type;
00075   typedef BidiIdxNode<value_type> node_type;
00077   typedef AutoSkipList<T,Pr,R> container_type;
00079   typedef T key_type;
00081 
00086   typedef T0 iterator;
00088   typedef T* pointer;
00090   typedef T& reference;
00092   typedef T mapped_type;
00094   typedef T& mapped_type_reference;
00096   typedef const T const_mapped_type;
00098   typedef const T& const_mapped_type_reference;
00100   typedef const T& const_reference;
00102   typedef T1 const_iterator;
00104 
00107   typedef std::reverse_iterator<iterator> reverse_iterator;
00109   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
00111   typedef std::pair<iterator, bool> slpair;
00113   typedef std::pair<iterator, iterator> ipair;
00115   typedef std::pair<const_iterator, const_iterator> const_ipair;
00117   typedef Pr key_compare;
00119   typedef Pr value_compare;
00120 
00121 private:
00122   R rng; 
00123   Pr Compare; 
00124   unsigned int maxLevel; 
00125   unsigned int level;    
00126   node_type *head;  
00127   node_type *tail; 
00128   double probability; 
00129   size_type items; 
00130   mutable size_type scan_index; 
00131   mutable std::pair<size_type,node_type*> *update; 
00132 
00134 
00138   void Init(double probability,unsigned int maxLevel) {}
00139 
00141 
00146   node_type* Alloc(unsigned int level, const T &obj) {}
00147 
00149 
00153   node_type* Alloc(unsigned int level) {}
00154 
00156 
00159   void Free(node_type *item) {}
00160 
00162 
00165   unsigned int GenerateRandomLevel() const {}
00166 
00168   void adjust_levels() {}
00169 
00171 
00177   void scan(const value_type &val) const{}
00178 
00180 
00186   void scan(size_type index) const{}
00187 
00189 
00195   void scan(const node_type *nodex) const{}
00196 
00198 
00205   void scan(const iterator &where) const{}
00206 public:
00207 
00209 
00212   class T0 : public std::iterator<std::random_access_iterator_tag, value_type>
00213   {
00214   public:
00215     typedef std::iterator<std::random_access_iterator_tag, value_type> baseclass;
00216     typedef std::random_acces_iterator_tag iterator_category;
00217     typedef typename baseclass::value_type value_type;
00218     typedef typename baseclass::value_type* pointer;
00219     typedef typename baseclass::value_type& reference;
00220     typedef ptrdiff_t difference_type;
00221 
00222     friend T1;
00223     friend container_type;
00224   private:
00225     container_type *container; 
00226     mutable size_type Findex; 
00227     node_type* node; 
00228   public:
00230     T0() {}
00232 
00235     T0(const T0 &t0){}
00236 
00238 
00241     T0(const T1 &t1){}
00242 
00244 
00250     T0(container_type *container, node_type* p){}
00251 
00253 
00258     T0(container_type *container, node_type* p, size_type index){}
00259 
00261 
00264     bool operator==(const T0& other) const{}
00265 
00267 
00270     bool operator!=(const T0& other) const{}
00271 
00273 
00276     bool operator==(const T1& other) const{}
00277 
00279 
00282     bool operator!=(const T1& other) const{}
00283 
00285 
00290     T0& operator++(){}
00291 
00293 
00298     T0 operator++(int){}
00299 
00301 
00306     T0& operator--(){}
00307 
00309 
00314     T0 operator--(int){}
00315 
00317 
00322     reference operator*() const{}
00323 
00325 
00330     pointer operator->() const{}
00331 
00333 
00336     bool operator<(const T0 &other) const{}
00337 
00339 
00342     bool operator<=(const T0 &other) const{}
00343 
00345 
00348     bool operator>(const T0 &other) const{}
00349 
00351 
00354     bool operator>=(const T0 &other) const{}
00355 
00357 
00360     bool operator<(const T1 &other) const{}
00361 
00363 
00366     bool operator<=(const T1 &other) const{}
00367 
00369 
00372     bool operator>(const T1 &other) const{}
00373 
00375 
00378     bool operator>=(const T1 &other) const{}
00379 
00381 
00385     T0 operator+(difference_type off) const{}
00386 
00388 
00392     T0 operator-(difference_type off) const{}
00393 
00395 
00399     T0& operator+=(difference_type off){}
00400 
00402 
00406     T0& operator-=(difference_type off){}
00407 
00409 
00413     difference_type operator-(const T0 &other) const{}
00414 
00416 
00420     difference_type operator-(const T1 &other) const{}
00421 
00423 
00429     int refresh(){}
00430 
00432 
00436     value_type& operator[](difference_type off) const{}
00437 
00439 
00442     size_type getIndex() const{}
00443   };
00444 
00446 
00449   class T1 : public std::iterator<std::random_access_iterator_tag, value_type, ptrdiff_t, const value_type*, const value_type&>
00450   {
00451   public:
00452     typedef std::iterator<std::random_access_iterator_tag, value_type> baseclass;
00453     typedef std::random_acces_iterator_tag iterator_category;
00454     typedef typename baseclass::value_type value_type;
00455     typedef typename const baseclass::value_type* pointer;
00456     typedef typename const baseclass::value_type& reference;
00457     typedef ptrdiff_t difference_type;
00458 
00459     friend T0;
00460     friend container_type;
00461   private:
00462     const container_type *container; 
00463     mutable size_type Findex; 
00464     const node_type* node; 
00465   public:
00467     T1() {}
00468 
00470 
00473     T1(const T1 &t1){}
00474 
00476 
00479     T1(const T0 &t0){}
00480 
00482 
00488     T1(container_type *container, node_type* p){}
00489 
00491 
00496     T1(container_type *container, node_type* p, size_type index){}
00497 
00499 
00502     bool operator==(const T0& other) const{}
00503 
00505 
00508     bool operator!=(const T0& other) const{}
00509 
00511 
00514     bool operator==(const T1& other) const{}
00515 
00517 
00520     bool operator!=(const T1& other) const{}
00521 
00523 
00528     T1& operator++(){}
00529 
00531 
00536     T1 operator++(int){}
00537 
00539 
00544     T1& operator--(){}
00545 
00547 
00552     T1 operator--(int){}
00553 
00555 
00560     reference operator*() const{}
00561 
00563 
00568     pointer operator->() const{}
00569 
00571 
00574     bool operator<(const T0 &other) const{}
00575 
00577 
00580     bool operator<=(const T0 &other) const{}
00581 
00583 
00586     bool operator>(const T0 &other) const{}
00587 
00589 
00592     bool operator>=(const T0 &other) const{}
00593 
00595 
00598     bool operator<(const T1 &other) const{}
00599 
00601 
00604     bool operator<=(const T1 &other) const{}
00605 
00607 
00610     bool operator>(const T1 &other) const{}
00611 
00613 
00616     bool operator>=(const T1 &other) const{}
00617 
00619 
00623     T1 operator+(difference_type off) const{}
00624 
00626 
00630     T1 operator-(difference_type off) const{}
00631 
00633 
00637     T1& operator+=(difference_type off){}
00638 
00640 
00644     T1& operator-=(difference_type off){}
00645 
00647 
00651     difference_type operator-(const T0 &other) const{}
00652 
00654 
00658     difference_type operator-(const T1 &other) const{}
00659 
00661 
00667     int refresh(){}
00668 
00670 
00674     value_type& operator[](difference_type off) const{}
00675 
00677 
00680     size_type getIndex() const{}
00681 
00682   };
00683 
00685 
00689   AutoSkipList(){}
00690 
00692 
00698   explicit AutoSkipList(size_type maxNodes){}
00699 
00701 
00705   AutoSkipList(double probability, unsigned int maxLevel){}
00706 
00708 
00713   AutoSkipList(const container_type &source){}
00714 
00716 
00723   template<class InIt> AutoSkipList(InIt first, InIt last){}
00724 
00726 
00732   template<class InIt> AutoSkipList(InIt first, InIt last, double probability, unsigned int maxLevel){}
00733 
00735 
00743   template<class InIt> AutoSkipList(InIt first, InIt last, size_type maxNodes){}
00744 
00746 
00752   explicit AutoSkipList(const key_compare& comp){}
00753 
00755 
00763   template<class InIt> AutoSkipList(InIt first, InIt last, const key_compare& comp){}
00764 
00766 
00773   template<class InIt> AutoSkipList(InIt first, InIt last, const key_compare& comp, double probability, unsigned int maxLevel){}
00774 
00776 
00785   template<class InIt> AutoSkipList(InIt first, InIt last, const key_compare& comp, size_type maxNodes) : Compare(comp){}
00786 
00788 
00791   ~AutoSkipList(){}
00792 
00793 
00795 
00801   container_type& operator=(const container_type &source){}
00802 
00804 
00807   iterator begin(){}
00808 
00810 
00813   iterator end(){}
00814 
00816 
00819   const_iterator begin() const{}
00820 
00822 
00825   const_iterator end() const{}
00826 
00828 
00831   reverse_iterator rbegin(){}
00832 
00834 
00837   reverse_iterator rend(){}
00838 
00840 
00843   const_reverse_iterator rbegin() const{}
00844 
00846 
00849   const_reverse_iterator rend() const{}
00850 
00852 
00855   size_type size() const{}
00856 
00858 
00861   bool empty() const{}
00862 
00864 
00867   reference front(){}
00868 
00870 
00873   const_reference front() const{}
00874 
00876 
00879   reference back(){}
00880 
00882 
00885   const_reference back() const{}
00886 
00888   void pop_front(){}
00889 
00891   void destroy_front(){}
00892 
00894   void pop_back(){}
00895 
00897   void destroy_back(){}
00898 
00900 
00904   template<class InIt> void assign(InIt first, InIt last){}
00905 
00907 
00917   slpair insert(const value_type& val){}
00918 
00920 
00926   iterator insert(const iterator &where, const value_type& val) {}
00927 
00929 
00933   template<class InIt> void insert(InIt first, InIt last) {}
00934 
00936   void clear(){}
00937 
00939   void destroy(){}
00940 
00942   iterator erase(const iterator &where){}
00943 
00945   iterator destroy(const iterator &where){}
00946 
00948 
00955   iterator erase(const iterator &first, const iterator &last){}
00956 
00958 
00965   iterator destroy(const iterator &first, const iterator &last){}
00966 
00968 
00972   size_type erase(const key_type &keyval){}
00973 
00975 
00979   size_type destroy(const key_type &keyval){}
00980 
00982 
00986   iterator erase_index(size_type index);
00987 
00989 
00993   iterator destroy_index(size_type index);
00994 
00996 
00999   void swap(container_type& right) {}
01000 
01002 
01005   template<class Pr1> void erase_if(Pr1 pred);
01006 
01008 
01011   template<class Pr4> void destroy_if(Pr4 pred);
01012 
01014 
01025   void cut(const iterator &first, const iterator &last, container_type& right);
01026 
01028 
01034   mapped_type_reference operator[](size_type index){}
01035 
01037 
01043   const_mapped_type_reference operator[](size_type index) const{}
01044 
01046 
01052   mapped_type_reference at(size_type off){}
01053 
01055 
01061   const_mapped_type_reference at(size_type off) const{}
01062 
01064   key_compare key_comp() const { }
01065 
01067   value_compare value_comp() const { }
01068 
01070   size_type max_size() const{}
01071 
01073 
01079   const key_type& key(const value_type& value) const {}
01080 
01082 
01088   mapped_type& value(value_type& value) {}
01089 
01091 
01095   iterator find(const key_type& keyval) {}
01096 
01098 
01102   const_iterator find(const key_type& keyval) const {}
01103 
01105 
01109   size_type count(const key_type& keyval) const {}
01110 
01111 
01113 
01117   iterator lower_bound(const key_type& keyval) {}
01118 
01120 
01124   const_iterator lower_bound(const key_type& keyval) const {}
01125 
01127 
01131   iterator upper_bound(const key_type& keyval) {}
01132 
01134 
01138   const_iterator upper_bound(const key_type& keyval) const {}
01139 
01141 
01145   ipair equal_range(const key_type& keyval) {}
01146 
01148 
01152   const_ipair equal_range(const key_type& keyval) const {}
01153 };
01154 
01156 
01161 template <class T, class Pr, class R>
01162 bool operator==(const AutoSkipList<T,Pr,R> &left, const AutoSkipList<T,Pr,R> &right)
01163 {
01164   return ((left.size() == right.size()) &&
01165           (std::equal(left.begin(), left.end(), right.begin())));
01166 
01167 }
01168 
01170 
01175 template <class T, class Pr, class R>
01176 bool operator!=(const AutoSkipList<T,Pr,R> &left, const AutoSkipList<T,Pr,R> &right)
01177 {
01178   return !(left==right);
01179 }
01180 
01182 
01187 template <class T, class Pr, class R>
01188 bool operator<(const AutoSkipList<T,Pr,R> &left, const AutoSkipList<T,Pr,R> &right)
01189 {
01190   return lexicographical_compare(left.begin(),left.end(),right.begin(),right.end(),left.value_comp());
01191 }
01192 
01194 
01199 template <class T, class Pr, class R>
01200 bool operator<=(const AutoSkipList<T,Pr,R> &left, const AutoSkipList<T,Pr,R> &right)
01201 {
01202   return !(right < left);
01203 }
01204 
01206 
01211 template <class T, class Pr, class R>
01212 bool operator>(const AutoSkipList<T,Pr,R> &left, const AutoSkipList<T,Pr,R> &right)
01213 {
01214   return (right < left);
01215 }
01216 
01218 
01223 template <class T, class Pr, class R>
01224 bool operator>=(const AutoSkipList<T,Pr,R> &left, const AutoSkipList<T,Pr,R> &right)
01225 {
01226   return !(left < right);
01227 }
01228 
01229 /*#define csarg1 template <class T, class Pr, class R>
01230 #define csarg2 AutoSkipList<T,Pr,R>
01231 CSDefineCompOps(csarg1, csarg2)
01232 #undef csarg1
01233 #undef csarg2
01234 
01235 #undef CSUNIQUE
01236 #define CSUNIQUE(a,b) b
01237 */
01238 
01240 
01287 template <class T, class Pr = std::less<T>, class R = RNG >
01288 class MultiAutoSkipList
01289 {
01290 public:
01291   class T0;
01292   class T1;
01293   friend class T0;
01294   friend class T1;
01296   typedef size_t size_type;
01298 
01301   typedef ptrdiff_t difference_type;
01303   typedef T value_type;
01305   typedef BidiIdxNode<value_type> node_type;
01307   typedef MultiAutoSkipList<T,Pr,R> container_type;
01309   typedef T key_type;
01311 
01316   typedef T0 iterator;
01318   typedef T* pointer;
01320   typedef T& reference;
01322   typedef T mapped_type;
01324   typedef T& mapped_type_reference;
01326   typedef const T const_mapped_type;
01328   typedef const T& const_mapped_type_reference;
01330   typedef const T& const_reference;
01332   typedef T1 const_iterator;
01334 
01337   typedef std::reverse_iterator<iterator> reverse_iterator;
01339   typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
01341   typedef std::pair<iterator, iterator> ipair;
01343   typedef std::pair<const_iterator, const_iterator> const_ipair;
01345   typedef Pr key_compare;
01347   typedef Pr value_compare;
01348 
01349 private:
01350   R rng; 
01351   Pr Compare; 
01352   unsigned int maxLevel; 
01353   unsigned int level;    
01354   node_type *head;  
01355   node_type *tail; 
01356   double probability; 
01357   size_type items; 
01358   mutable size_type scan_index; 
01359   mutable std::pair<size_type,node_type*> *update; 
01360 
01362 
01366   void Init(double probability, unsigned int maxLevel) {}
01367 
01369 
01374   node_type* Alloc(unsigned int level, const T &obj) {}
01375 
01377 
01381   node_type* Alloc(unsigned int level) {}
01382 
01384 
01387   void Free(node_type *item) {}
01388 
01390 
01393   unsigned int GenerateRandomLevel() const {}
01394 
01396   void adjust_levels() {}
01397 
01399 
01405   void scan(const value_type &val) const{}
01406 
01408 
01414   void scan(size_type index) const{}
01415 
01417 
01423   void scan(const node_type *nodex) const{}
01424 
01426 
01433   void scan(const iterator &where) const{}
01434 
01435 public:
01437 
01440   class T0 : public std::iterator<std::random_access_iterator_tag, value_type>
01441   {
01442   public:
01443     typedef std::iterator<std::random_access_iterator_tag, value_type> baseclass;
01444     typedef std::random_acces_iterator_tag iterator_category;
01445     typedef typename baseclass::value_type value_type;
01446     typedef typename baseclass::value_type* pointer;
01447     typedef typename baseclass::value_type& reference;
01448     typedef ptrdiff_t difference_type;
01449 
01450     friend T1;
01451     friend container_type;
01452   private:
01453     container_type *container; 
01454     mutable size_type Findex; 
01455     node_type* node; 
01456   public:
01458     T0() {}
01460 
01463     T0(const T0 &t0){}
01464 
01466 
01469     T0(const T1 &t1){}
01470 
01472 
01478     T0(container_type *container, node_type* p){}
01479 
01481 
01486     T0(container_type *container, node_type* p, size_type index){}
01487 
01489 
01492     bool operator==(const T0& other) const{}
01493 
01495 
01498     bool operator!=(const T0& other) const{}
01499 
01501 
01504     bool operator==(const T1& other) const{}
01505 
01507 
01510     bool operator!=(const T1& other) const{}
01511 
01513 
01518     T0& operator++(){}
01519 
01521 
01526     T0 operator++(int){}
01527 
01529 
01534     T0& operator--(){}
01535 
01537 
01542     T0 operator--(int){}
01543 
01545 
01550     reference operator*() const{}
01551 
01553 
01558     pointer operator->() const{}
01559 
01561 
01564     bool operator<(const T0 &other) const{}
01565 
01567 
01570     bool operator<=(const T0 &other) const{}
01571 
01573 
01576     bool operator>(const T0 &other) const{}
01577 
01579 
01582     bool operator>=(const T0 &other) const{}
01583 
01585 
01588     bool operator<(const T1 &other) const{}
01589 
01591 
01594     bool operator<=(const T1 &other) const{}
01595 
01597 
01600     bool operator>(const T1 &other) const{}
01601 
01603 
01606     bool operator>=(const T1 &other) const{}
01607 
01609 
01613     T0 operator+(difference_type off) const{}
01614 
01616 
01620     T0 operator-(difference_type off) const{}
01621 
01623 
01627     T0& operator+=(difference_type off){}
01628 
01630 
01634     T0& operator-=(difference_type off){}
01635 
01637 
01641     difference_type operator-(const T0 &other) const{}
01642 
01644 
01648     difference_type operator-(const T1 &other) const{}
01649 
01651 
01657     int refresh(){}
01658 
01660 
01664     value_type& operator[](difference_type off) const{}
01665 
01667 
01670     size_type getIndex() const{}
01671   };
01672 
01674 
01677   class T1 : public std::iterator<std::random_access_iterator_tag, T, ptrdiff_t, const value_type*, const value_type&>
01678   {
01679   public:
01680     typedef std::iterator<std::random_access_iterator_tag, value_type> baseclass;
01681     typedef std::random_acces_iterator_tag iterator_category;
01682     typedef typename baseclass::value_type value_type;
01683     typedef typename const baseclass::value_type* pointer;
01684     typedef typename const baseclass::value_type& reference;
01685     typedef ptrdiff_t difference_type;
01686 
01687     friend T0;
01688     friend container_type;
01689   private:
01690     const container_type *container; 
01691     mutable size_type Findex; 
01692     const node_type* node; 
01693   public:
01695     T1() {}
01696 
01698 
01701     T1(const T1 &t1){}
01702 
01704 
01707     T1(const T0 &t0){}
01708 
01710 
01716     T1(container_type *container, node_type* p){}
01717 
01719 
01724     T1(container_type *container, node_type* p, size_type index){}
01725 
01727 
01730     bool operator==(const T0& other) const{}
01731 
01733 
01736     bool operator!=(const T0& other) const{}
01737 
01739 
01742     bool operator==(const T1& other) const{}
01743 
01745 
01748     bool operator!=(const T1& other) const{}
01749 
01751 
01756     T1& operator++(){}
01757 
01759 
01764     T1 operator++(int){}
01765 
01767 
01772     T1& operator--(){}
01773 
01775 
01780     T1 operator--(int){}
01781 
01783 
01788     reference operator*() const{}
01789 
01791 
01796     pointer operator->() const{}
01797 
01799 
01802     bool operator<(const T0 &other) const{}
01803 
01805 
01808     bool operator<=(const T0 &other) const{}
01809 
01811 
01814     bool operator>(const T0 &other) const{}
01815 
01817 
01820     bool operator>=(const T0 &other) const{}
01821 
01823 
01826     bool operator<(const T1 &other) const{}
01827 
01829 
01832     bool operator<=(const T1 &other) const{}
01833 
01835 
01838     bool operator>(const T1 &other) const{}
01839 
01841 
01844     bool operator>=(const T1 &other) const{}
01845 
01847 
01851     T1 operator+(difference_type off) const{}
01852 
01854 
01858     T1 operator-(difference_type off) const{}
01859 
01861 
01865     T1& operator+=(difference_type off){}
01866 
01868 
01872     T1& operator-=(difference_type off){}
01873 
01875 
01879     difference_type operator-(const T0 &other) const{}
01880 
01882 
01886     difference_type operator-(const T1 &other) const{}
01887 
01889 
01895     int refresh(){}
01896 
01898 
01902     value_type& operator[](difference_type off) const{}
01903 
01905 
01908     size_type getIndex() const{}
01909 
01910   };
01911 
01912 
01914 
01918   MultiAutoSkipList(){}
01919 
01921 
01927   explicit MultiAutoSkipList(size_type maxNodes){}
01928 
01930 
01934   MultiAutoSkipList(double probability, unsigned int maxLevel){}
01935 
01937 
01942   MultiAutoSkipList(const container_type &source){}
01943 
01945 
01952   template<class InIt> MultiAutoSkipList(InIt first, InIt last){}
01953 
01955 
01961   template<class InIt> MultiAutoSkipList(InIt first, InIt last, double probability, unsigned int maxLevel){}
01962 
01964 
01972   template<class InIt> MultiAutoSkipList(InIt first, InIt last, size_type maxNodes){}
01973 
01975 
01981   explicit MultiAutoSkipList(const key_compare& comp){}
01982 
01984 
01992   template<class InIt> MultiAutoSkipList(InIt first, InIt last, const key_compare& comp){}
01993 
01995 
02002   template<class InIt> MultiAutoSkipList(InIt first, InIt last, const key_compare& comp, double probability, unsigned int maxLevel){}
02003 
02005 
02014   template<class InIt> MultiAutoSkipList(InIt first, InIt last, const key_compare& comp, size_type maxNodes) : Compare(comp){}
02015 
02017 
02020   ~MultiAutoSkipList(){}
02021 
02022 
02024 
02030   container_type& operator=(const container_type &source){}
02031 
02033 
02036   iterator begin(){}
02037 
02039 
02042   iterator end(){}
02043 
02045 
02048   const_iterator begin() const{}
02049 
02051 
02054   const_iterator end() const{}
02055 
02057 
02060   reverse_iterator rbegin(){}
02061 
02063 
02066   reverse_iterator rend(){}
02067 
02069 
02072   const_reverse_iterator rbegin() const{}
02073 
02075 
02078   const_reverse_iterator rend() const{}
02079 
02081 
02084   size_type size() const{}
02085 
02087 
02090   bool empty() const{}
02091 
02093 
02096   reference front(){}
02097 
02099 
02102   const_reference front() const{}
02103 
02105 
02108   reference back(){}
02109 
02111 
02114   const_reference back() const{}
02115 
02117   void pop_front(){}
02118 
02120   void destroy_front(){}
02121 
02123   void pop_back(){}
02124 
02126   void destroy_back(){}
02127 
02129 
02133   template<class InIt> void assign(InIt first, InIt last){}
02134 
02136 
02140   iterator insert(const value_type& val){}
02141 
02143 
02149   iterator insert(const iterator &where, const value_type& val) {}
02150 
02152 
02156   template<class InIt> void insert(InIt first, InIt last) {}
02157 
02159   void clear(){}
02160 
02162   void destroy(){}
02163 
02165   iterator erase(const iterator &where){}
02166 
02168   iterator destroy(const iterator &where){}
02169 
02171 
02178   iterator erase(const iterator &first, const iterator &last){}
02179 
02181 
02188   iterator destroy(const iterator &first, const iterator &last){}
02189 
02191 
02195   size_type erase(const key_type &keyval){}
02196 
02198 
02202   size_type destroy(const key_type &keyval){}
02203 
02205 
02209   iterator erase_index(size_type index);
02210 
02212 
02216   iterator destroy_index(size_type index);
02217 
02219 
02222   void swap(container_type& right) {}
02223 
02225 
02228   template<class Pr1> void erase_if(Pr1 pred);
02229 
02231 
02234   template<class Pr4> void destroy_if(Pr4 pred);
02235 
02237 
02248   void cut(const iterator &first, const iterator &last, container_type& right);
02249 
02251 
02257   mapped_type_reference operator[](size_type index){}
02258 
02260 
02266   const_mapped_type_reference operator[](size_type index) const{}
02267 
02269 
02275   mapped_type_reference at(size_type off){}
02276 
02278 
02284   const_mapped_type_reference at(size_type off) const{}
02285 
02287   key_compare key_comp() const { }
02288 
02290   value_compare value_comp() const { }
02291 
02293   size_type max_size() const{}
02294 
02296 
02302   const key_type& key(const value_type& value) const {}
02303 
02305 
02311   mapped_type& value(value_type& value) {}
02312 
02314 
02318   iterator find(const key_type& keyval) {}
02319 
02321 
02325   const_iterator find(const key_type& keyval) const {}
02326 
02328 
02332   size_type count(const key_type& keyval) const {}
02333 
02334 
02336 
02340   iterator lower_bound(const key_type& keyval) {}
02341 
02343 
02347   const_iterator lower_bound(const key_type& keyval) const {}
02348 
02350 
02354   iterator upper_bound(const key_type& keyval) {}
02355 
02357 
02361   const_iterator upper_bound(const key_type& keyval) const {}
02362 
02364 
02368   ipair equal_range(const key_type& keyval) {}
02369 
02371 
02375   const_ipair equal_range(const key_type& keyval) const {}
02376 };
02377 
02379 
02384 template <class T, class Pr, class R>
02385 bool operator==(const MultiAutoSkipList<T,Pr,R> &left, const MultiAutoSkipList<T,Pr,R> &right)
02386 {
02387   return ((left.size() == right.size()) &&
02388           (std::equal(left.begin(), left.end(), right.begin())));
02389 }
02390 
02392 
02397 template <class T, class Pr, class R>
02398 bool operator!=(const MultiAutoSkipList<T,Pr,R> &left, const MultiAutoSkipList<T,Pr,R> &right)
02399 {
02400   return !(left==right);
02401 }
02402 
02404 
02409 template <class T, class Pr, class R>
02410 bool operator<(const MultiAutoSkipList<T,Pr,R> &left, const MultiAutoSkipList<T,Pr,R> &right)
02411 {
02412   return lexicographical_compare(left.begin(),left.end(),right.begin(),right.end(),left.value_comp());
02413 }
02414 
02416 
02421 template <class T, class Pr, class R>
02422 bool operator<=(const MultiAutoSkipList<T,Pr,R> &left, const MultiAutoSkipList<T,Pr,R> &right)
02423 {
02424   return !(right < left);
02425 }
02426 
02428 
02433 template <class T, class Pr, class R>
02434 bool operator>(const MultiAutoSkipList<T,Pr,R> &left, const MultiAutoSkipList<T,Pr,R> &right)
02435 {
02436   return (right < left);
02437 }
02438 
02440 
02445 template <class T, class Pr, class R>
02446 bool operator>=(const MultiAutoSkipList<T,Pr,R> &left, const MultiAutoSkipList<T,Pr,R> &right)
02447 {
02448   return !(left < right);
02449 }
02450 
02451 
02452 /*#define csarg1 template <class T, class Pr, class R>
02453 #define csarg2 MultiAutoSkipList<T,Pr,R>
02454 CSDefineCompOps(csarg1, csarg2)
02455 #undef csarg1
02456 #undef csarg2
02457 */
 All Classes Files Functions Variables Typedefs