00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00038 #ifndef BLOCXX_LIST_HPP_INCLUDE_GUARD_
00039 #define BLOCXX_LIST_HPP_INCLUDE_GUARD_
00040 #include "blocxx/BLOCXX_config.h"
00041 #include "blocxx/COWReference.hpp"
00042 #include <list>
00043
00044 namespace BLOCXX_NAMESPACE
00045 {
00046
00047
00048 template<class T> class List;
00049
00050 template <class T>
00051 inline bool operator==(const List<T>& x, const List<T>& y);
00052
00053 template <class T>
00054 inline bool operator<(const List<T>& x, const List<T>& y);
00055
00056
00060 template<class T> class List
00061 {
00062 private:
00063 typedef std::list<T> L;
00064 COWReference<L> m_impl;
00065 public:
00066 typedef typename L::value_type value_type;
00067 typedef typename L::pointer pointer;
00068 typedef typename L::const_pointer const_pointer;
00069 typedef typename L::reference reference;
00070 typedef typename L::const_reference const_reference;
00071 typedef typename L::size_type size_type;
00072 typedef typename L::difference_type difference_type;
00073 typedef typename L::iterator iterator;
00074 typedef typename L::const_iterator const_iterator;
00075 typedef typename L::reverse_iterator reverse_iterator;
00076 typedef typename L::const_reverse_iterator const_reverse_iterator;
00077
00081 List() : m_impl(new L) {}
00086 explicit List(L* toWrap) : m_impl(toWrap)
00087 {
00088 }
00094 template<class InputIterator>
00095 List(InputIterator first, InputIterator last)
00096 : m_impl(new L(first, last))
00097 {
00098 }
00106 List(size_type n, const T& value) : m_impl(new L(n, value))
00107 {
00108 }
00116 List(int n, const T& value) : m_impl(new L(n, value))
00117 {
00118 }
00126 List(long n, const T& value) : m_impl(new L(n, value))
00127 {
00128 }
00134 explicit List(size_type n) : m_impl(new L(n))
00135 {
00136 }
00141 L* getImpl()
00142 {
00143 return &*m_impl;
00144 }
00150 iterator begin()
00151 {
00152 return m_impl->begin();
00153 }
00159 const_iterator begin() const
00160 {
00161 return m_impl->begin();
00162 }
00168 iterator end()
00169 {
00170 return m_impl->end();
00171 }
00177 const_iterator end() const
00178 {
00179 return m_impl->end();
00180 }
00186 reverse_iterator rbegin()
00187 {
00188 return m_impl->rbegin();
00189 }
00195 const_reverse_iterator rbegin() const
00196 {
00197 return m_impl->rbegin();
00198 }
00204 reverse_iterator rend()
00205 {
00206 return m_impl->rend();
00207 }
00213 const_reverse_iterator rend() const
00214 {
00215 return m_impl->rend();
00216 }
00220 bool empty() const
00221 {
00222 return m_impl->empty();
00223 }
00227 size_type size() const
00228 {
00229 return m_impl->size();
00230 }
00234 size_type max_size() const
00235 {
00236 return m_impl->max_size();
00237 }
00241 reference front()
00242 {
00243 return m_impl->front();
00244 }
00248 const_reference front() const
00249 {
00250 return m_impl->front();
00251 }
00255 reference back()
00256 {
00257 return m_impl->back();
00258 }
00262 const_reference back() const
00263 {
00264 return m_impl->back();
00265 }
00270 void swap(List<T>& x)
00271 {
00272 m_impl.swap(x.m_impl);
00273 }
00282 iterator insert(iterator position, const T& x)
00283 {
00284 return m_impl->insert(position, x);
00285 }
00293 iterator insert(iterator position)
00294 {
00295 return m_impl->insert(position);
00296 }
00304 template<class InputIterator>
00305 void insert(iterator position, InputIterator first, InputIterator last)
00306 {
00307 m_impl->insert(position, first, last);
00308 }
00318 void insert(iterator pos, size_type n, const T& x)
00319 {
00320 m_impl->insert(pos, n, x);
00321 }
00331 void insert(iterator pos, int n, const T& x)
00332 {
00333 m_impl->insert(pos, n, x);
00334 }
00344 void insert(iterator pos, long n, const T& x)
00345 {
00346 m_impl->insert(pos, n, x);
00347 }
00353 void push_front(const T& x)
00354 {
00355 m_impl->push_front(x);
00356 }
00362 void push_back(const T& x)
00363 {
00364 m_impl->push_back(x);
00365 }
00373 iterator erase(iterator position)
00374 {
00375 return m_impl->erase(position);
00376 }
00386 iterator erase(iterator first, iterator last)
00387 {
00388 return m_impl->erase(first, last);
00389 }
00396 void resize(size_type new_size, const T& x)
00397 {
00398 m_impl->resize(new_size, x);
00399 }
00406 void resize(size_type new_size)
00407 {
00408 m_impl->resize(new_size);
00409 }
00414 void clear()
00415 {
00416 m_impl->clear();
00417 }
00427 const_iterator find(const T &x, const_iterator first,
00428 const_iterator last) const
00429 {
00430 for( ; first != end(); ++first)
00431 {
00432 if( x == *first)
00433 return first;
00434 if( first == last)
00435 break;
00436 }
00437 return end();
00438 }
00445 const_iterator find(const T &x) const
00446 {
00447 return find(x, begin(), end());
00448 }
00458 iterator find(const T &x, iterator first, iterator last)
00459 {
00460 for( ; first != end(); ++first)
00461 {
00462 if( x == *first)
00463 return first;
00464 if( first == last)
00465 break;
00466 }
00467 return end();
00468 }
00475 iterator find(const T &x)
00476 {
00477 return find(x, begin(), end());
00478 }
00488 bool contains(const T& x, const_iterator first,
00489 const_iterator last) const
00490 {
00491 return find(x, first, last) != end();
00492 }
00498 bool contains(const T& x) const
00499 {
00500 return find(x, begin(), end()) != end();
00501 }
00505 void pop_front()
00506 {
00507 m_impl->pop_front();
00508 }
00512 void pop_back()
00513 {
00514 m_impl->pop_back();
00515 }
00522 void splice(iterator position, List& x)
00523 {
00524 m_impl->splice(position, *x.m_impl);
00525 }
00534 void splice(iterator position, List& x, iterator i)
00535 {
00536 m_impl->splice(position, *x.m_impl, i);
00537 }
00547 void splice(iterator position, List& x, iterator first, iterator last)
00548 {
00549 m_impl->splice(position, *x.m_impl, first, last);
00550 }
00555 void remove(const T& value)
00556 {
00557 m_impl->remove(value);
00558 }
00562 void unique()
00563 {
00564 m_impl->unique();
00565 }
00571 void merge(List& x)
00572 {
00573 m_impl->merge(*x.m_impl);
00574 }
00578 void reverse()
00579 {
00580 m_impl->reverse();
00581 }
00585 void sort()
00586 {
00587 m_impl->sort();
00588 }
00594 template<class Predicate> void remove_if (Predicate p)
00595 {
00596 m_impl->remove_if (p);
00597 }
00603 template<class BinaryPredicate> void unique(BinaryPredicate bp)
00604 {
00605 m_impl->unique(bp);
00606 }
00612 template<class StrictWeakOrdering> void merge(List& x, StrictWeakOrdering swo)
00613 {
00614 m_impl->merge(*x.m_impl, swo);
00615 }
00620 template<class StrictWeakOrdering> void sort(StrictWeakOrdering swo)
00621 {
00622 m_impl->sort(swo);
00623 }
00632 friend bool operator== <>(const List<T>& x, const List<T>& y);
00640 friend bool operator< <>(const List<T>& x, const List<T>& y);
00641 };
00642 template <class T>
00643 inline bool operator==(const List<T>& x, const List<T>& y)
00644 {
00645 return *x.m_impl == *y.m_impl;
00646 }
00647 template <class T>
00648 inline bool operator<(const List<T>& x, const List<T>& y)
00649 {
00650 return *x.m_impl < *y.m_impl;
00651 }
00652 template <class T>
00653 inline void swap(List<T>& x, List<T>& y)
00654 {
00655 x.swap(y);
00656 }
00657 template <class T>
00658 std::list<T>* COWReferenceClone(std::list<T>* obj)
00659 {
00660 return new std::list<T>(*obj);
00661 }
00662
00663 }
00664
00665 #endif