ptr_map.hpp 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165
  1. //
  2. // Boost.Pointer Container
  3. //
  4. // Copyright Thorsten Ottosen 2003-2005. Use, modification and
  5. // distribution is subject to the Boost Software License, Version
  6. // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
  7. // http://www.boost.org/LICENSE_1_0.txt)
  8. //
  9. // For more information, see http://www.boost.org/libs/ptr_container/
  10. //
  11. #ifndef BOOST_PTR_CONTAINER_PTR_MAP_HPP
  12. #define BOOST_PTR_CONTAINER_PTR_MAP_HPP
  13. #if defined(_MSC_VER) && (_MSC_VER >= 1200)
  14. # pragma once
  15. #endif
  16. #include <map>
  17. #include <boost/ptr_container/ptr_map_adapter.hpp>
  18. namespace boost
  19. {
  20. template
  21. <
  22. class Key,
  23. class T,
  24. class Compare = std::less<Key>,
  25. class CloneAllocator = heap_clone_allocator,
  26. class Allocator = std::allocator< std::pair<const Key,void*> >
  27. >
  28. class ptr_map :
  29. public ptr_map_adapter<T,std::map<Key,void*,
  30. Compare,Allocator>,CloneAllocator>
  31. {
  32. typedef ptr_map_adapter<T,std::map<Key,void*,
  33. Compare,Allocator>,CloneAllocator>
  34. base_type;
  35. typedef ptr_map<Key,T,Compare,CloneAllocator,Allocator> this_type;
  36. public:
  37. ptr_map()
  38. { }
  39. explicit ptr_map( const Compare& comp,
  40. const Allocator& a = Allocator() )
  41. : base_type( comp, a ) { }
  42. template< class InputIterator >
  43. ptr_map( InputIterator first, InputIterator last )
  44. : base_type( first, last )
  45. { }
  46. template< class InputIterator >
  47. ptr_map( InputIterator first, InputIterator last,
  48. const Compare& comp,
  49. const Allocator& a = Allocator() )
  50. : base_type( first, last, comp, a )
  51. { }
  52. BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_map, base_type,
  53. this_type )
  54. template< class U >
  55. ptr_map( const ptr_map<Key,U>& r ) : base_type( r )
  56. { }
  57. ptr_map& operator=( ptr_map r )
  58. {
  59. this->swap( r );
  60. return *this;
  61. }
  62. };
  63. template
  64. <
  65. class Key,
  66. class T,
  67. class Compare = std::less<Key>,
  68. class CloneAllocator = heap_clone_allocator,
  69. class Allocator = std::allocator< std::pair<const Key,void*> >
  70. >
  71. class ptr_multimap :
  72. public ptr_multimap_adapter<T,std::multimap<Key,void*,
  73. Compare,Allocator>,CloneAllocator>
  74. {
  75. typedef ptr_multimap_adapter<T,std::multimap<Key,void*,
  76. Compare,Allocator>,CloneAllocator>
  77. base_type;
  78. typedef ptr_multimap<Key,T,Compare,CloneAllocator,Allocator> this_type;
  79. public:
  80. ptr_multimap()
  81. { }
  82. explicit ptr_multimap( const Compare& comp,
  83. const Allocator& a = Allocator() )
  84. : base_type( comp, a ) { }
  85. template< class InputIterator >
  86. ptr_multimap( InputIterator first, InputIterator last )
  87. : base_type( first, last )
  88. { }
  89. template< class InputIterator >
  90. ptr_multimap( InputIterator first, InputIterator last,
  91. const Compare& comp,
  92. const Allocator& a = Allocator() )
  93. : base_type( first, last, comp, a )
  94. { }
  95. BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_multimap,
  96. base_type,
  97. this_type )
  98. template< class U >
  99. ptr_multimap( const ptr_multimap<Key,U>& r ) : base_type( r )
  100. { }
  101. ptr_multimap& operator=( ptr_multimap r )
  102. {
  103. this->swap( r );
  104. return *this;
  105. }
  106. };
  107. //////////////////////////////////////////////////////////////////////////////
  108. // clonability
  109. template< class K, class T, class C, class CA, class A >
  110. inline ptr_map<K,T,C,CA,A>* new_clone( const ptr_map<K,T,C,CA,A>& r )
  111. {
  112. return r.clone().release();
  113. }
  114. template< class K, class T, class C, class CA, class A >
  115. inline ptr_multimap<K,T,C,CA,A>* new_clone( const ptr_multimap<K,T,C,CA,A>& r )
  116. {
  117. return r.clone().release();
  118. }
  119. /////////////////////////////////////////////////////////////////////////
  120. // swap
  121. template< typename K, typename T, typename C, typename CA, typename A >
  122. inline void swap( ptr_map<K,T,C,CA,A>& l, ptr_map<K,T,C,CA,A>& r )
  123. {
  124. l.swap(r);
  125. }
  126. template< typename K, typename T, typename C, typename CA, typename A >
  127. inline void swap( ptr_multimap<K,T,C,CA,A>& l, ptr_multimap<K,T,C,CA,A>& r )
  128. {
  129. l.swap(r);
  130. }
  131. }
  132. #endif