ceph/src/boost/boost/container/container_fwd.hpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright Ion Gaztanaga 2005-2014. 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
  11 #ifndef BOOST_CONTAINER_CONTAINER_FWD_HPP
  12 #define BOOST_CONTAINER_CONTAINER_FWD_HPP
  13
  14 #ifndef BOOST_CONFIG_HPP
  15 #  include <boost/config.hpp>
  16 #endif
  17
  18 #if defined(BOOST_HAS_PRAGMA_ONCE)
  19 #  pragma once
  20 #endif
  21
  22 //! \file
  23 //! This header file forward declares the following containers:
  24 //!   - boost::container::vector
  25 //!   - boost::container::stable_vector
  26 //!   - boost::container::static_vector
  27 //!   - boost::container::small_vector
  28 //!   - boost::container::slist
  29 //!   - boost::container::list
  30 //!   - boost::container::set
  31 //!   - boost::container::multiset
  32 //!   - boost::container::map
  33 //!   - boost::container::multimap
  34 //!   - boost::container::flat_set
  35 //!   - boost::container::flat_multiset
  36 //!   - boost::container::flat_map
  37 //!   - boost::container::flat_multimap
  38 //!   - boost::container::basic_string
  39 //!   - boost::container::string
  40 //!   - boost::container::wstring
  41 //!
  42 //! Forward declares the following allocators:
  43 //!   - boost::container::allocator
  44 //!   - boost::container::node_allocator
  45 //!   - boost::container::adaptive_pool
  46 //!
  47 //! Forward declares the following polymorphic resource classes:
  48 //!   - boost::container::pmr::memory_resource
  49 //!   - boost::container::pmr::polymorphic_allocator
  50 //!   - boost::container::pmr::monotonic_buffer_resource
  51 //!   - boost::container::pmr::pool_options
  52 //!   - boost::container::pmr::unsynchronized_pool_resource
  53 //!   - boost::container::pmr::synchronized_pool_resource
  54 //!
  55 //! And finally it defines the following types
  56
  57 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
  58
  59 //Std forward declarations
  60 #ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP
  61    #include <boost/container/detail/std_fwd.hpp>
  62 #endif
  63
  64 namespace boost{
  65 namespace intrusive{
  66 namespace detail{
  67    //Create namespace to avoid compilation errors
  68 }}}
  69
  70 namespace boost{ namespace container{ namespace container_detail{
  71    namespace bi = boost::intrusive;
  72    namespace bid = boost::intrusive::detail;
  73 }}}
  74
  75 namespace boost{ namespace container{ namespace pmr{
  76    namespace bi = boost::intrusive;
  77    namespace bid = boost::intrusive::detail;
  78 }}}
  79
  80 #include <cstddef>
  81
  82 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
  83
  84 //////////////////////////////////////////////////////////////////////////////
  85 //                             Containers
  86 //////////////////////////////////////////////////////////////////////////////
  87
  88 namespace boost {
  89 namespace container {
  90
  91 //! Enumeration used to configure ordered associative containers
  92 //! with a concrete tree implementation.
  93 enum tree_type_enum
  94 {
  95    red_black_tree,
  96    avl_tree,
  97    scapegoat_tree,
  98    splay_tree
  99 };
 100
 101 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 102
 103 template<class T>
 104 class new_allocator;
 105
 106 template <class T
 107          ,class Allocator = new_allocator<T> >
 108 class vector;
 109
 110 template <class T
 111          ,class Allocator = new_allocator<T> >
 112 class stable_vector;
 113
 114 template <class T, std::size_t Capacity>
 115 class static_vector;
 116
 117 template < class T, std::size_t N
 118          , class Allocator= new_allocator<T> >
 119 class small_vector;
 120
 121 template <class T
 122          ,class Allocator = new_allocator<T> >
 123 class deque;
 124
 125 template <class T
 126          ,class Allocator = new_allocator<T> >
 127 class list;
 128
 129 template <class T
 130          ,class Allocator = new_allocator<T> >
 131 class slist;
 132
 133 template<tree_type_enum TreeType, bool OptimizeSize>
 134 struct tree_opt;
 135
 136 typedef tree_opt<red_black_tree, true> tree_assoc_defaults;
 137
 138 template <class Key
 139          ,class Compare  = std::less<Key>
 140          ,class Allocator = new_allocator<Key>
 141          ,class Options = tree_assoc_defaults >
 142 class set;
 143
 144 template <class Key
 145          ,class Compare  = std::less<Key>
 146          ,class Allocator = new_allocator<Key>
 147          ,class Options = tree_assoc_defaults >
 148 class multiset;
 149
 150 template <class Key
 151          ,class T
 152          ,class Compare  = std::less<Key>
 153          ,class Allocator = new_allocator<std::pair<const Key, T> >
 154          ,class Options = tree_assoc_defaults >
 155 class map;
 156
 157 template <class Key
 158          ,class T
 159          ,class Compare  = std::less<Key>
 160          ,class Allocator = new_allocator<std::pair<const Key, T> >
 161          ,class Options = tree_assoc_defaults >
 162 class multimap;
 163
 164 template <class Key
 165          ,class Compare  = std::less<Key>
 166          ,class Allocator = new_allocator<Key> >
 167 class flat_set;
 168
 169 template <class Key
 170          ,class Compare  = std::less<Key>
 171          ,class Allocator = new_allocator<Key> >
 172 class flat_multiset;
 173
 174 template <class Key
 175          ,class T
 176          ,class Compare  = std::less<Key>
 177          ,class Allocator = new_allocator<std::pair<Key, T> > >
 178 class flat_map;
 179
 180 template <class Key
 181          ,class T
 182          ,class Compare  = std::less<Key>
 183          ,class Allocator = new_allocator<std::pair<Key, T> > >
 184 class flat_multimap;
 185
 186 template <class CharT
 187          ,class Traits = std::char_traits<CharT>
 188          ,class Allocator  = new_allocator<CharT> >
 189 class basic_string;
 190
 191 typedef basic_string
 192    <char
 193    ,std::char_traits<char>
 194    ,new_allocator<char> >
 195 string;
 196
 197 typedef basic_string
 198    <wchar_t
 199    ,std::char_traits<wchar_t>
 200    ,new_allocator<wchar_t> >
 201 wstring;
 202
 203 static const std::size_t ADP_nodes_per_block    = 256u;
 204 static const std::size_t ADP_max_free_blocks    = 2u;
 205 static const std::size_t ADP_overhead_percent   = 1u;
 206 static const std::size_t ADP_only_alignment     = 0u;
 207
 208 template < class T
 209          , std::size_t NodesPerBlock   = ADP_nodes_per_block
 210          , std::size_t MaxFreeBlocks   = ADP_max_free_blocks
 211          , std::size_t OverheadPercent = ADP_overhead_percent
 212          , unsigned Version = 2
 213          >
 214 class adaptive_pool;
 215
 216 template < class T
 217          , unsigned Version = 2
 218          , unsigned int AllocationDisableMask = 0>
 219 class allocator;
 220
 221 static const std::size_t NodeAlloc_nodes_per_block = 256u;
 222
 223 template
 224    < class T
 225    , std::size_t NodesPerBlock = NodeAlloc_nodes_per_block
 226    , std::size_t Version = 2>
 227 class node_allocator;
 228
 229 namespace pmr {
 230
 231 class memory_resource;
 232
 233 template<class T>
 234 class polymorphic_allocator;
 235
 236 class monotonic_buffer_resource;
 237
 238 struct pool_options;
 239
 240 template <class Allocator>
 241 class resource_adaptor_imp;
 242
 243 class unsynchronized_pool_resource;
 244
 245 class synchronized_pool_resource;
 246
 247 }  //namespace pmr {
 248
 249 #else
 250
 251 //! Default options for tree-based associative containers
 252 //!   - tree_type<red_black_tree>
 253 //!   - optimize_size<true>
 254 typedef implementation_defined tree_assoc_defaults;
 255
 256 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 257
 258 //! Type used to tag that the input range is
 259 //! guaranteed to be ordered
 260 struct ordered_range_t
 261 {};
 262
 263 //! Value used to tag that the input range is
 264 //! guaranteed to be ordered
 265 static const ordered_range_t ordered_range = ordered_range_t();
 266
 267 //! Type used to tag that the input range is
 268 //! guaranteed to be ordered and unique
 269 struct ordered_unique_range_t
 270    : public ordered_range_t
 271 {};
 272
 273 //! Value used to tag that the input range is
 274 //! guaranteed to be ordered and unique
 275 static const ordered_unique_range_t ordered_unique_range = ordered_unique_range_t();
 276
 277 //! Type used to tag that the inserted values
 278 //! should be default initialized
 279 struct default_init_t
 280 {};
 281
 282 //! Value used to tag that the inserted values
 283 //! should be default initialized
 284 static const default_init_t default_init = default_init_t();
 285 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 286
 287 //! Type used to tag that the inserted values
 288 //! should be value initialized
 289 struct value_init_t
 290 {};
 291
 292 //! Value used to tag that the inserted values
 293 //! should be value initialized
 294 static const value_init_t value_init = value_init_t();
 295
 296 namespace container_detail_really_deep_namespace {
 297
 298 //Otherwise, gcc issues a warning of previously defined
 299 //anonymous_instance and unique_instance
 300 struct dummy
 301 {
 302    dummy()
 303    {
 304       (void)ordered_range;
 305       (void)ordered_unique_range;
 306       (void)default_init;
 307    }
 308 };
 309
 310 }  //detail_really_deep_namespace {
 311
 312
 313 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 314
 315 }}  //namespace boost { namespace container {
 316
 317 #endif //#ifndef BOOST_CONTAINER_CONTAINER_FWD_HPP