// Copyright (C) 2000, 2001 Stephen Cleary

 //

 // Distributed under the Boost Software License, Version 1.0. (See

 // accompanying file LICENSE_1_0.txt or copy at

 // http://www.boost.org/LICENSE_1_0.txt)

 //

 // See http://www.boost.org for updates, documentation, and revision history.

 #ifndef BOOST_POOL_ALLOC_HPP

 #define BOOST_POOL_ALLOC_HPP

 // std::numeric_limits

 #include <boost/limits.hpp>

 // new, std::bad_alloc

 #include <new>

 #include <boost/pool/poolfwd.hpp>

 // boost::singleton_pool

 #include <boost/pool/singleton_pool.hpp>

 #include <boost/detail/workaround.hpp>

 // The following code will be put into Boost.Config in a later revision

 #if defined(_RWSTD_VER) || defined(__SGI_STL_PORT) || \

     BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))

  #define BOOST_NO_PROPER_STL_DEALLOCATE

 #endif

 namespace boost {

 struct pool_allocator_tag { };

 template <typename T,

     typename UserAllocator,

     typename Mutex,

     unsigned NextSize>

 class pool_allocator

 {

   public:

     typedef T value_type;

     typedef UserAllocator user_allocator;

     typedef Mutex mutex;

     BOOST_STATIC_CONSTANT(unsigned, next_size = NextSize);

     typedef value_type * pointer;

     typedef const value_type * const_pointer;

     typedef value_type & reference;

     typedef const value_type & const_reference;

     typedef typename pool<UserAllocator>::size_type size_type;

     typedef typename pool<UserAllocator>::difference_type difference_type;

     template <typename U>

     struct rebind

     {

       typedef pool_allocator<U, UserAllocator, Mutex, NextSize> other;

     };

   public:

     pool_allocator() { }

     // default copy constructor

     // default assignment operator

     // not explicit, mimicking std::allocator [20.4.1]

     template <typename U>

     pool_allocator(const pool_allocator<U, UserAllocator, Mutex, NextSize> &)

     { }

     // default destructor

     static pointer address(reference r)

     { return &r; }

     static const_pointer address(const_reference s)

     { return &s; }

     static size_type max_size()

     { return (std::numeric_limits<size_type>::max)(); }

     static void construct(const pointer ptr, const value_type & t)

     { new (ptr) T(t); }

     static void destroy(const pointer ptr)

     {

       ptr->~T();

       (void) ptr; // avoid unused variable warning

     }

     bool operator==(const pool_allocator &) const

     { return true; }

     bool operator!=(const pool_allocator &) const

     { return false; }

     static pointer allocate(const size_type n)

     {

       const pointer ret = static_cast<pointer>(

           singleton_pool<pool_allocator_tag, sizeof(T), UserAllocator, Mutex,

               NextSize>::ordered_malloc(n) );

       if (ret == 0)

         throw std::bad_alloc();

       return ret;

     }

     static pointer allocate(const size_type n, const void * const)

     { return allocate(n); }

     static void deallocate(const pointer ptr, const size_type n)

     {

 #ifdef BOOST_NO_PROPER_STL_DEALLOCATE

       if (ptr == 0 || n == 0)

         return;

 #endif

       singleton_pool<pool_allocator_tag, sizeof(T), UserAllocator, Mutex,

           NextSize>::ordered_free(ptr, n);

     }

 };

 struct fast_pool_allocator_tag { };

 template <typename T,

     typename UserAllocator,

     typename Mutex,

     unsigned NextSize>

 class fast_pool_allocator

 {

   public:

     typedef T value_type;

     typedef UserAllocator user_allocator;

     typedef Mutex mutex;

     BOOST_STATIC_CONSTANT(unsigned, next_size = NextSize);

     typedef value_type * pointer;

     typedef const value_type * const_pointer;

     typedef value_type & reference;

     typedef const value_type & const_reference;

     typedef typename pool<UserAllocator>::size_type size_type;

     typedef typename pool<UserAllocator>::difference_type difference_type;

     template <typename U>

     struct rebind

     {

       typedef fast_pool_allocator<U, UserAllocator, Mutex, NextSize> other;

     };

   public:

     fast_pool_allocator() { }

     // default copy constructor

     // default assignment operator

     // not explicit, mimicking std::allocator [20.4.1]

     template <typename U>

     fast_pool_allocator(

         const fast_pool_allocator<U, UserAllocator, Mutex, NextSize> &)

     { }

     // default destructor

     static pointer address(reference r)

     { return &r; }

     static const_pointer address(const_reference s)

     { return &s; }

     static size_type max_size()

     { return (std::numeric_limits<size_type>::max)(); }

     void construct(const pointer ptr, const value_type & t)

     { new (ptr) T(t); }

     void destroy(const pointer ptr)

     {

       ptr->~T();

       (void) ptr; // avoid unused variable warning

     }

     bool operator==(const fast_pool_allocator &) const

     { return true; }

     bool operator!=(const fast_pool_allocator &) const

     { return false; }

     static pointer allocate(const size_type n)

     {

       const pointer ret = (n == 1) ? 

           static_cast<pointer>(

               singleton_pool<fast_pool_allocator_tag, sizeof(T),

                   UserAllocator, Mutex, NextSize>::malloc() ) :

           static_cast<pointer>(

               singleton_pool<fast_pool_allocator_tag, sizeof(T),

                   UserAllocator, Mutex, NextSize>::ordered_malloc(n) );

       if (ret == 0)

         throw std::bad_alloc();

       return ret;

     }

     static pointer allocate(const size_type n, const void * const)

     { return allocate(n); }

     static pointer allocate()

     {

       const pointer ret = static_cast<pointer>(

           singleton_pool<fast_pool_allocator_tag, sizeof(T),

               UserAllocator, Mutex, NextSize>::malloc() );

       if (ret == 0)

         throw std::bad_alloc();

       return ret;

     }

     static void deallocate(const pointer ptr, const size_type n)

     {

 #ifdef BOOST_NO_PROPER_STL_DEALLOCATE

       if (ptr == 0 || n == 0)

         return;

 #endif

       if (n == 1)

         singleton_pool<fast_pool_allocator_tag, sizeof(T),

             UserAllocator, Mutex, NextSize>::free(ptr);

       else

         singleton_pool<fast_pool_allocator_tag, sizeof(T),

             UserAllocator, Mutex, NextSize>::free(ptr, n);

     }

     static void deallocate(const pointer ptr)

     {

       singleton_pool<fast_pool_allocator_tag, sizeof(T),

           UserAllocator, Mutex, NextSize>::free(ptr);

     }

 };

 } // namespace boost

 #endif