/Src/Dependencies/Boost/boost/interprocess/containers/container/detail/multiallocation_chain.hpp

http://hadesmem.googlecode.com/ · C++ Header · 245 lines · 170 code · 63 blank · 12 comment · 0 complexity · a7f0455240fd1902a6507d1b7474062d MD5 · raw file

  1. //////////////////////////////////////////////////////////////////////////////
  2. //
  3. // (C) Copyright Ion Gaztanaga 2005-2009. Distributed under the Boost
  4. // Software License, Version 1.0. (See accompanying file
  5. // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  6. //
  7. // See http://www.boost.org/libs/container for documentation.
  8. //
  9. //////////////////////////////////////////////////////////////////////////////
  10. #ifndef BOOST_CONTAINERS_DETAIL_MULTIALLOCATION_CHAIN_HPP
  11. #define BOOST_CONTAINERS_DETAIL_MULTIALLOCATION_CHAIN_HPP
  12. #include "config_begin.hpp"
  13. #include INCLUDE_BOOST_CONTAINER_CONTAINER_FWD_HPP
  14. #include INCLUDE_BOOST_CONTAINER_DETAIL_UTILITIES_HPP
  15. #include INCLUDE_BOOST_CONTAINER_DETAIL_TYPE_TRAITS_HPP
  16. #include INCLUDE_BOOST_CONTAINER_DETAIL_TRANSFORM_ITERATOR_HPP
  17. #include <boost/intrusive/slist.hpp>
  18. #include <boost/pointer_to_other.hpp>
  19. #include INCLUDE_BOOST_CONTAINER_MOVE_HPP
  20. namespace boost {
  21. namespace container {
  22. namespace containers_detail {
  23. template<class VoidPointer>
  24. class basic_multiallocation_chain
  25. {
  26. private:
  27. typedef bi::slist_base_hook<bi::void_pointer<VoidPointer>
  28. ,bi::link_mode<bi::normal_link>
  29. > node;
  30. typedef bi::slist< node
  31. , bi::linear<true>
  32. , bi::cache_last<true>
  33. > slist_impl_t;
  34. slist_impl_t slist_impl_;
  35. static node & to_node(VoidPointer p)
  36. { return *static_cast<node*>(static_cast<void*>(containers_detail::get_pointer(p))); }
  37. BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(basic_multiallocation_chain)
  38. public:
  39. typedef VoidPointer void_pointer;
  40. typedef typename slist_impl_t::iterator iterator;
  41. basic_multiallocation_chain()
  42. : slist_impl_()
  43. {}
  44. basic_multiallocation_chain(BOOST_MOVE_MACRO_RV_REF(basic_multiallocation_chain) other)
  45. : slist_impl_()
  46. { slist_impl_.swap(other.slist_impl_); }
  47. basic_multiallocation_chain& operator=(BOOST_MOVE_MACRO_RV_REF(basic_multiallocation_chain) other)
  48. {
  49. basic_multiallocation_chain tmp(BOOST_CONTAINER_MOVE_NAMESPACE::move(other));
  50. this->swap(tmp);
  51. return *this;
  52. }
  53. bool empty() const
  54. { return slist_impl_.empty(); }
  55. std::size_t size() const
  56. { return slist_impl_.size(); }
  57. iterator before_begin()
  58. { return slist_impl_.before_begin(); }
  59. iterator begin()
  60. { return slist_impl_.begin(); }
  61. iterator end()
  62. { return slist_impl_.end(); }
  63. iterator last()
  64. { return slist_impl_.last(); }
  65. void clear()
  66. { slist_impl_.clear(); }
  67. iterator insert_after(iterator it, void_pointer m)
  68. { return slist_impl_.insert_after(it, to_node(m)); }
  69. void push_front(void_pointer m)
  70. { return slist_impl_.push_front(to_node(m)); }
  71. void push_back(void_pointer m)
  72. { return slist_impl_.push_back(to_node(m)); }
  73. void pop_front()
  74. { return slist_impl_.pop_front(); }
  75. void *front()
  76. { return &*slist_impl_.begin(); }
  77. void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end)
  78. { slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end); }
  79. void splice_after(iterator after_this, basic_multiallocation_chain &x, iterator before_begin, iterator before_end, std::size_t n)
  80. { slist_impl_.splice_after(after_this, x.slist_impl_, before_begin, before_end, n); }
  81. void splice_after(iterator after_this, basic_multiallocation_chain &x)
  82. { slist_impl_.splice_after(after_this, x.slist_impl_); }
  83. void incorporate_after(iterator after_this, void_pointer begin , iterator before_end)
  84. { slist_impl_.incorporate_after(after_this, &to_node(begin), &to_node(before_end)); }
  85. void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, std::size_t n)
  86. { slist_impl_.incorporate_after(after_this, &to_node(begin), &to_node(before_end), n); }
  87. void swap(basic_multiallocation_chain &x)
  88. { slist_impl_.swap(x.slist_impl_); }
  89. static iterator iterator_to(void_pointer p)
  90. { return slist_impl_t::s_iterator_to(to_node(p)); }
  91. std::pair<void_pointer, void_pointer> extract_data()
  92. {
  93. std::pair<void_pointer, void_pointer> ret
  94. (slist_impl_.begin().operator->()
  95. ,slist_impl_.last().operator->());
  96. slist_impl_.clear();
  97. return ret;
  98. }
  99. };
  100. template<class T>
  101. struct cast_functor
  102. {
  103. typedef typename containers_detail::add_reference<T>::type result_type;
  104. template<class U>
  105. result_type operator()(U &ptr) const
  106. { return *static_cast<T*>(static_cast<void*>(&ptr)); }
  107. };
  108. template<class MultiallocationChain, class T>
  109. class transform_multiallocation_chain
  110. {
  111. private:
  112. BOOST_MOVE_MACRO_MOVABLE_BUT_NOT_COPYABLE(transform_multiallocation_chain)
  113. MultiallocationChain holder_;
  114. typedef typename MultiallocationChain::void_pointer void_pointer;
  115. typedef typename boost::pointer_to_other
  116. <void_pointer, T>::type pointer;
  117. static pointer cast(void_pointer p)
  118. {
  119. return pointer(static_cast<T*>(containers_detail::get_pointer(p)));
  120. }
  121. public:
  122. typedef transform_iterator
  123. < typename MultiallocationChain::iterator
  124. , containers_detail::cast_functor <T> > iterator;
  125. transform_multiallocation_chain()
  126. : holder_()
  127. {}
  128. transform_multiallocation_chain(BOOST_MOVE_MACRO_RV_REF(transform_multiallocation_chain) other)
  129. : holder_()
  130. { this->swap(other); }
  131. transform_multiallocation_chain(BOOST_MOVE_MACRO_RV_REF(MultiallocationChain) other)
  132. : holder_(BOOST_CONTAINER_MOVE_NAMESPACE::move(other))
  133. {}
  134. transform_multiallocation_chain& operator=(BOOST_MOVE_MACRO_RV_REF(transform_multiallocation_chain) other)
  135. {
  136. transform_multiallocation_chain tmp(BOOST_CONTAINER_MOVE_NAMESPACE::move(other));
  137. this->swap(tmp);
  138. return *this;
  139. }
  140. void push_front(pointer mem)
  141. { holder_.push_front(mem); }
  142. void swap(transform_multiallocation_chain &other_chain)
  143. { holder_.swap(other_chain.holder_); }
  144. void splice_after(iterator after_this, transform_multiallocation_chain &x, iterator before_begin, iterator before_end, std::size_t n)
  145. { holder_.splice_after(after_this.base(), x.holder_, before_begin.base(), before_end.base(), n); }
  146. void incorporate_after(iterator after_this, void_pointer begin, void_pointer before_end, std::size_t n)
  147. { holder_.incorporate_after(after_this.base(), begin, before_end, n); }
  148. void pop_front()
  149. { holder_.pop_front(); }
  150. pointer front()
  151. { return cast(holder_.front()); }
  152. bool empty() const
  153. { return holder_.empty(); }
  154. iterator before_begin()
  155. { return iterator(holder_.before_begin()); }
  156. iterator begin()
  157. { return iterator(holder_.begin()); }
  158. iterator end()
  159. { return iterator(holder_.end()); }
  160. iterator last()
  161. { return iterator(holder_.last()); }
  162. std::size_t size() const
  163. { return holder_.size(); }
  164. void clear()
  165. { holder_.clear(); }
  166. iterator insert_after(iterator it, pointer m)
  167. { return iterator(holder_.insert_after(it.base(), m)); }
  168. static iterator iterator_to(pointer p)
  169. { return iterator(MultiallocationChain::iterator_to(p)); }
  170. std::pair<void_pointer, void_pointer> extract_data()
  171. { return holder_.extract_data(); }
  172. MultiallocationChain extract_multiallocation_chain()
  173. {
  174. return MultiallocationChain(BOOST_CONTAINER_MOVE_NAMESPACE::move(holder_));
  175. }
  176. };
  177. }}}
  178. // namespace containers_detail {
  179. // namespace container {
  180. // namespace boost {
  181. #include INCLUDE_BOOST_CONTAINER_DETAIL_CONFIG_END_HPP
  182. #endif //BOOST_CONTAINERS_DETAIL_MULTIALLOCATION_CHAIN_HPP