/Src/Dependencies/Boost/boost/interprocess/containers/container/container_fwd.hpp

http://hadesmem.googlecode.com/ · C++ Header · 187 lines · 96 code · 45 blank · 46 comment · 1 complexity · dbc6b47f07004c1cb181177d3a503d6c 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_CONTAINERS_FWD_HPP
  11. #define BOOST_CONTAINERS_CONTAINERS_FWD_HPP
  12. #if (defined _MSC_VER) && (_MSC_VER >= 1200)
  13. # pragma once
  14. #endif
  15. //////////////////////////////////////////////////////////////////////////////
  16. // Standard predeclarations
  17. //////////////////////////////////////////////////////////////////////////////
  18. /// @cond
  19. namespace boost{
  20. namespace intrusive{
  21. //Create namespace to avoid compilation errors
  22. }}
  23. namespace boost{ namespace container{ namespace containers_detail{
  24. namespace bi = boost::intrusive;
  25. }}}
  26. namespace std {
  27. template <class T>
  28. class allocator;
  29. template <class T>
  30. struct less;
  31. template <class T1, class T2>
  32. struct pair;
  33. template <class CharType>
  34. struct char_traits;
  35. } //namespace std {
  36. /// @endcond
  37. //////////////////////////////////////////////////////////////////////////////
  38. // Containers
  39. //////////////////////////////////////////////////////////////////////////////
  40. namespace boost {
  41. namespace container {
  42. //vector class
  43. template <class T
  44. ,class A = std::allocator<T> >
  45. class vector;
  46. //vector class
  47. template <class T
  48. ,class A = std::allocator<T> >
  49. class stable_vector;
  50. //vector class
  51. template <class T
  52. ,class A = std::allocator<T> >
  53. class deque;
  54. //list class
  55. template <class T
  56. ,class A = std::allocator<T> >
  57. class list;
  58. //slist class
  59. template <class T
  60. ,class Alloc = std::allocator<T> >
  61. class slist;
  62. //set class
  63. template <class T
  64. ,class Pred = std::less<T>
  65. ,class Alloc = std::allocator<T> >
  66. class set;
  67. //multiset class
  68. template <class T
  69. ,class Pred = std::less<T>
  70. ,class Alloc = std::allocator<T> >
  71. class multiset;
  72. //map class
  73. template <class Key
  74. ,class T
  75. ,class Pred = std::less<Key>
  76. ,class Alloc = std::allocator<std::pair<const Key, T> > >
  77. class map;
  78. //multimap class
  79. template <class Key
  80. ,class T
  81. ,class Pred = std::less<Key>
  82. ,class Alloc = std::allocator<std::pair<const Key, T> > >
  83. class multimap;
  84. //flat_set class
  85. template <class T
  86. ,class Pred = std::less<T>
  87. ,class Alloc = std::allocator<T> >
  88. class flat_set;
  89. //flat_multiset class
  90. template <class T
  91. ,class Pred = std::less<T>
  92. ,class Alloc = std::allocator<T> >
  93. class flat_multiset;
  94. //flat_map class
  95. template <class Key
  96. ,class T
  97. ,class Pred = std::less<Key>
  98. ,class Alloc = std::allocator<std::pair<Key, T> > >
  99. class flat_map;
  100. //flat_multimap class
  101. template <class Key
  102. ,class T
  103. ,class Pred = std::less<Key>
  104. ,class Alloc = std::allocator<std::pair<Key, T> > >
  105. class flat_multimap;
  106. //basic_string class
  107. template <class CharT
  108. ,class Traits = std::char_traits<CharT>
  109. ,class Alloc = std::allocator<CharT> >
  110. class basic_string;
  111. //! Type used to tag that the input range is
  112. //! guaranteed to be ordered
  113. struct ordered_range_impl_t {};
  114. //! Type used to tag that the input range is
  115. //! guaranteed to be ordered and unique
  116. struct ordered_unique_range_impl_t{};
  117. /// @cond
  118. typedef ordered_range_impl_t * ordered_range_t;
  119. typedef ordered_unique_range_impl_t *ordered_unique_range_t;
  120. /// @endcond
  121. //! Value used to tag that the input range is
  122. //! guaranteed to be ordered
  123. static const ordered_range_t ordered_range = 0;
  124. //! Value used to tag that the input range is
  125. //! guaranteed to be ordered and unique
  126. static const ordered_unique_range_t ordered_unique_range = 0;
  127. /// @cond
  128. namespace detail_really_deep_namespace {
  129. //Otherwise, gcc issues a warning of previously defined
  130. //anonymous_instance and unique_instance
  131. struct dummy
  132. {
  133. dummy()
  134. {
  135. (void)ordered_range;
  136. (void)ordered_unique_range;
  137. }
  138. };
  139. } //detail_really_deep_namespace {
  140. /// @endcond
  141. }} //namespace boost { namespace container {
  142. #endif //#ifndef BOOST_CONTAINERS_CONTAINERS_FWD_HPP