boost/interprocess/interprocess_fwd.hpp

   1 //////////////////////////////////////////////////////////////////////////////
   2 //
   3 // (C) Copyright Ion Gaztanaga 2005-2008. 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/interprocess for documentation.
   8 //
   9 //////////////////////////////////////////////////////////////////////////////
  10
  11 #ifndef BOOST_INTERPROCESS_FWD_HPP
  12 #define BOOST_INTERPROCESS_FWD_HPP
  13
  14 #if defined (_MSC_VER) && (_MSC_VER >= 1200)
  15 #  pragma once
  16 #endif
  17
  18 #include <boost/interprocess/detail/config_begin.hpp>
  19 #include <boost/interprocess/detail/workaround.hpp>
  20
  21 #include <cstddef>
  22
  23 //////////////////////////////////////////////////////////////////////////////
  24 //                        Standard predeclarations
  25 //////////////////////////////////////////////////////////////////////////////
  26
  27 /// @cond
  28
  29 namespace boost{
  30 namespace intrusive{
  31 }}
  32
  33 namespace boost{
  34 namespace interprocess{
  35 namespace bi = boost::intrusive;
  36 }}
  37
  38 namespace std {
  39
  40 template <class T>
  41 class allocator;
  42
  43 template <class T>
  44 struct less;
  45
  46 template <class T1, class T2>
  47 struct pair;
  48
  49 template <class CharType>
  50 struct char_traits;
  51
  52 }  //namespace std {
  53
  54 /// @endcond
  55
  56 namespace boost { namespace interprocess {
  57
  58 //////////////////////////////////////////////////////////////////////////////
  59 //                            shared_memory
  60 //////////////////////////////////////////////////////////////////////////////
  61
  62 class shared_memory_object;
  63
  64 #if defined (BOOST_INTERPROCESS_WINDOWS)
  65 class windows_shared_memory;
  66 #endif   //#if defined (BOOST_INTERPROCESS_WINDOWS)
  67
  68 //////////////////////////////////////////////////////////////////////////////
  69 //              mapped file/mapped region/mapped_file
  70 //////////////////////////////////////////////////////////////////////////////
  71
  72 class file_mapping;
  73 class mapped_region;
  74 class mapped_file;
  75
  76 //////////////////////////////////////////////////////////////////////////////
  77 //                               Mutexes
  78 //////////////////////////////////////////////////////////////////////////////
  79
  80 class null_mutex;
  81
  82 class interprocess_mutex;
  83 class interprocess_recursive_mutex;
  84
  85 class named_mutex;
  86 class named_recursive_mutex;
  87
  88 class interprocess_semaphore;
  89 class named_semaphore;
  90
  91 //////////////////////////////////////////////////////////////////////////////
  92 //                         Mutex families
  93 //////////////////////////////////////////////////////////////////////////////
  94
  95 struct mutex_family;
  96 struct null_mutex_family;
  97
  98 //////////////////////////////////////////////////////////////////////////////
  99 //                   Other synchronization classes
 100 //////////////////////////////////////////////////////////////////////////////
 101
 102 class barrier;
 103 class interprocess_sharable_mutex;
 104 class interprocess_condition;
 105
 106 //////////////////////////////////////////////////////////////////////////////
 107 //                              Locks
 108 //////////////////////////////////////////////////////////////////////////////
 109
 110 template <class Mutex>
 111 class scoped_lock;
 112
 113 template <class SharableMutex>
 114 class sharable_lock;
 115
 116 template <class UpgradableMutex>
 117 class upgradable_lock;
 118
 119 //////////////////////////////////////////////////////////////////////////////
 120 //                      STL compatible allocators
 121 //////////////////////////////////////////////////////////////////////////////
 122
 123 template<class T, class SegmentManager>
 124 class allocator;
 125
 126 template<class T, class SegmentManager, std::size_t NodesPerBlock = 64>
 127 class node_allocator;
 128
 129 template<class T, class SegmentManager, std::size_t NodesPerBlock = 64>
 130 class private_node_allocator;
 131
 132 template<class T, class SegmentManager, std::size_t NodesPerBlock = 64>
 133 class cached_node_allocator;
 134
 135 template<class T, class SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2
 136          , unsigned char OverheadPercent = 5
 137 >
 138 class adaptive_pool;
 139
 140 template<class T, class SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2
 141          , unsigned char OverheadPercent = 5
 142 >
 143 class private_adaptive_pool;
 144
 145 template<class T, class SegmentManager, std::size_t NodesPerBlock = 64, std::size_t MaxFreeBlocks = 2
 146          , unsigned char OverheadPercent = 5
 147 >
 148 class cached_adaptive_pool;
 149
 150
 151 //////////////////////////////////////////////////////////////////////////////
 152 //                            offset_ptr
 153 //////////////////////////////////////////////////////////////////////////////
 154
 155 template <class T>
 156 class offset_ptr;
 157
 158 //////////////////////////////////////////////////////////////////////////////
 159 //                    Memory allocation algorithms
 160 //////////////////////////////////////////////////////////////////////////////
 161
 162 //Single segment memory allocation algorithms
 163 template<class MutexFamily, class VoidMutex = offset_ptr<void> >
 164 class simple_seq_fit;
 165
 166 template<class MutexFamily, class VoidMutex = offset_ptr<void>, std::size_t MemAlignment = 0>
 167 class rbtree_best_fit;
 168
 169 //////////////////////////////////////////////////////////////////////////////
 170 //                         Index Types
 171 //////////////////////////////////////////////////////////////////////////////
 172
 173 template<class IndexConfig> class flat_map_index;
 174 template<class IndexConfig> class iset_index;
 175 template<class IndexConfig> class iunordered_set_index;
 176 template<class IndexConfig> class map_index;
 177 template<class IndexConfig> class null_index;
 178 template<class IndexConfig> class unordered_map_index;
 179
 180 //////////////////////////////////////////////////////////////////////////////
 181 //                         Segment manager
 182 //////////////////////////////////////////////////////////////////////////////
 183
 184 template <class CharType
 185          ,class MemoryAlgorithm
 186          ,template<class IndexConfig> class IndexType>
 187 class segment_manager;
 188
 189 //////////////////////////////////////////////////////////////////////////////
 190 //                  External buffer managed memory classes
 191 //////////////////////////////////////////////////////////////////////////////
 192
 193 template <class CharType
 194          ,class MemoryAlgorithm
 195          ,template<class IndexConfig> class IndexType>
 196 class basic_managed_external_buffer;
 197
 198 typedef basic_managed_external_buffer
 199    <char
 200    ,rbtree_best_fit<null_mutex_family>
 201    ,iset_index>
 202 managed_external_buffer;
 203
 204 typedef basic_managed_external_buffer
 205    <wchar_t
 206    ,rbtree_best_fit<null_mutex_family>
 207    ,iset_index>
 208 wmanaged_external_buffer;
 209
 210 //////////////////////////////////////////////////////////////////////////////
 211 //                      managed memory classes
 212 //////////////////////////////////////////////////////////////////////////////
 213
 214 template <class CharType
 215          ,class MemoryAlgorithm
 216          ,template<class IndexConfig> class IndexType>
 217 class basic_managed_shared_memory;
 218
 219 typedef basic_managed_shared_memory
 220    <char
 221    ,rbtree_best_fit<mutex_family>
 222    ,iset_index>
 223 managed_shared_memory;
 224
 225 typedef basic_managed_shared_memory
 226    <wchar_t
 227    ,rbtree_best_fit<mutex_family>
 228    ,iset_index>
 229 wmanaged_shared_memory;
 230
 231
 232 //////////////////////////////////////////////////////////////////////////////
 233 //                      Windows shared memory managed memory classes
 234 //////////////////////////////////////////////////////////////////////////////
 235
 236 #if defined (BOOST_INTERPROCESS_WINDOWS)
 237
 238 template <class CharType
 239          ,class MemoryAlgorithm
 240          ,template<class IndexConfig> class IndexType>
 241 class basic_managed_windows_shared_memory;
 242
 243 typedef basic_managed_windows_shared_memory
 244    <char
 245    ,rbtree_best_fit<mutex_family>
 246    ,iset_index>
 247 managed_windows_shared_memory;
 248
 249 typedef basic_managed_windows_shared_memory
 250    <wchar_t
 251    ,rbtree_best_fit<mutex_family>
 252    ,iset_index>
 253 wmanaged_windows_shared_memory;
 254
 255 #else
 256
 257 template <class CharType
 258          ,class MemoryAlgorithm
 259          ,template<class IndexConfig> class IndexType>
 260 class basic_managed_xsi_shared_memory;
 261
 262 typedef basic_managed_xsi_shared_memory
 263    <char
 264    ,rbtree_best_fit<mutex_family>
 265    ,iset_index>
 266 managed_xsi_shared_memory;
 267
 268 typedef basic_managed_xsi_shared_memory
 269    <wchar_t
 270    ,rbtree_best_fit<mutex_family>
 271    ,iset_index>
 272 wmanaged_xsi_shared_memory;
 273
 274 #endif   //#if defined (BOOST_INTERPROCESS_WINDOWS)
 275
 276 //////////////////////////////////////////////////////////////////////////////
 277 //                      Fixed address shared memory
 278 //////////////////////////////////////////////////////////////////////////////
 279
 280 typedef basic_managed_shared_memory
 281    <char
 282    ,rbtree_best_fit<mutex_family, void*>
 283    ,iset_index>
 284 fixed_managed_shared_memory;
 285
 286 typedef basic_managed_shared_memory
 287    <wchar_t
 288    ,rbtree_best_fit<mutex_family, void*>
 289    ,iset_index>
 290 wfixed_managed_shared_memory;
 291
 292 //////////////////////////////////////////////////////////////////////////////
 293 //                      Heap memory managed memory classes
 294 //////////////////////////////////////////////////////////////////////////////
 295
 296 template
 297    <class CharType
 298    ,class MemoryAlgorithm
 299    ,template<class IndexConfig> class IndexType>
 300 class basic_managed_heap_memory;
 301
 302 typedef basic_managed_heap_memory
 303    <char
 304    ,rbtree_best_fit<null_mutex_family>
 305    ,iset_index>
 306 managed_heap_memory;
 307
 308 typedef basic_managed_heap_memory
 309    <wchar_t
 310    ,rbtree_best_fit<null_mutex_family>
 311    ,iset_index>
 312 wmanaged_heap_memory;
 313
 314 //////////////////////////////////////////////////////////////////////////////
 315 //                         Mapped file managed memory classes
 316 //////////////////////////////////////////////////////////////////////////////
 317
 318 template
 319    <class CharType
 320    ,class MemoryAlgorithm
 321    ,template<class IndexConfig> class IndexType>
 322 class basic_managed_mapped_file;
 323
 324 typedef basic_managed_mapped_file
 325    <char
 326    ,rbtree_best_fit<mutex_family>
 327    ,iset_index>
 328 managed_mapped_file;
 329
 330 typedef basic_managed_mapped_file
 331    <wchar_t
 332    ,rbtree_best_fit<mutex_family>
 333    ,iset_index>
 334 wmanaged_mapped_file;
 335
 336 //////////////////////////////////////////////////////////////////////////////
 337 //                            Exceptions
 338 //////////////////////////////////////////////////////////////////////////////
 339
 340 class interprocess_exception;
 341 class lock_exception;
 342 class bad_alloc;
 343
 344 //////////////////////////////////////////////////////////////////////////////
 345 //                            Bufferstream
 346 //////////////////////////////////////////////////////////////////////////////
 347
 348 //bufferstream
 349 template <class CharT
 350          ,class CharTraits = std::char_traits<CharT> >
 351 class basic_bufferbuf;
 352
 353 template <class CharT
 354          ,class CharTraits = std::char_traits<CharT> >
 355 class basic_ibufferstream;
 356
 357 template <class CharT
 358          ,class CharTraits = std::char_traits<CharT> >
 359 class basic_obufferstream;
 360
 361 template <class CharT
 362          ,class CharTraits = std::char_traits<CharT> >
 363 class basic_bufferstream;
 364
 365 //////////////////////////////////////////////////////////////////////////////
 366 //                            Vectorstream
 367 //////////////////////////////////////////////////////////////////////////////
 368
 369 template <class CharVector
 370          ,class CharTraits = std::char_traits<typename CharVector::value_type> >
 371 class basic_vectorbuf;
 372
 373 template <class CharVector
 374          ,class CharTraits = std::char_traits<typename CharVector::value_type> >
 375 class basic_ivectorstream;
 376
 377 template <class CharVector
 378          ,class CharTraits = std::char_traits<typename CharVector::value_type> >
 379 class basic_ovectorstream;
 380
 381 template <class CharVector
 382          ,class CharTraits = std::char_traits<typename CharVector::value_type> >
 383 class basic_vectorstream;
 384
 385 //////////////////////////////////////////////////////////////////////////////
 386 //                             Smart pointers
 387 //////////////////////////////////////////////////////////////////////////////
 388
 389 template<class T, class Deleter>
 390 class scoped_ptr;
 391
 392 template<class T, class VoidPointer>
 393 class intrusive_ptr;
 394
 395 template<class T, class VoidAllocator, class Deleter>
 396 class shared_ptr;
 397
 398 template<class T, class VoidAllocator, class Deleter>
 399 class weak_ptr;
 400
 401 //////////////////////////////////////////////////////////////////////////////
 402 //                                  IPC
 403 //////////////////////////////////////////////////////////////////////////////
 404
 405 class message_queue;
 406
 407 }}  //namespace boost { namespace interprocess {
 408
 409 //////////////////////////////////////////////////////////////////////////////
 410 //                                  CONTAINERS
 411 //////////////////////////////////////////////////////////////////////////////
 412
 413 #include <boost/interprocess/detail/config_end.hpp>
 414
 415 #endif //#ifndef BOOST_INTERPROCESS_FWD_HPP