// 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_SINGLETON_POOL_HPP

 #define BOOST_SINGLETON_POOL_HPP

 #include <boost/pool/poolfwd.hpp>

 // boost::pool

 #include <boost/pool/pool.hpp>

 // boost::details::pool::singleton_default

 #include <boost/pool/detail/singleton.hpp>

 // boost::details::pool::guard

 #include <boost/pool/detail/guard.hpp>

 namespace boost {

 //

 // The singleton_pool class allows other pool interfaces for types of the same

 //   size to share the same pool

 //

 template <typename Tag, unsigned RequestedSize,

     typename UserAllocator,

     typename Mutex,

     unsigned NextSize>

 struct singleton_pool

 {

   public:

     typedef Tag tag;

     typedef Mutex mutex;

     typedef UserAllocator user_allocator;

     typedef typename pool<UserAllocator>::size_type size_type;

     typedef typename pool<UserAllocator>::difference_type difference_type;

     BOOST_STATIC_CONSTANT(unsigned, requested_size = RequestedSize);

     BOOST_STATIC_CONSTANT(unsigned, next_size = NextSize);

   private:

     struct pool_type: Mutex

     {

       pool<UserAllocator> p;

       pool_type():p(RequestedSize, NextSize) { }

     };

     typedef details::pool::singleton_default<pool_type> singleton;

     singleton_pool();

   public:

     static void * malloc()

     {

       pool_type & p = singleton::instance();

       details::pool::guard<Mutex> g(p);

       return p.p.malloc();

     }

     static void * ordered_malloc()

     {

       pool_type & p = singleton::instance();

       details::pool::guard<Mutex> g(p);

       return p.p.ordered_malloc();

     }

     static void * ordered_malloc(const size_type n)

     {

       pool_type & p = singleton::instance();

       details::pool::guard<Mutex> g(p);

       return p.p.ordered_malloc(n);

     }

     static bool is_from(void * const ptr)

     {

       pool_type & p = singleton::instance();

       details::pool::guard<Mutex> g(p);

       return p.p.is_from(ptr);

     }

     static void free(void * const ptr)

     {

       pool_type & p = singleton::instance();

       details::pool::guard<Mutex> g(p);

       p.p.free(ptr);

     }

     static void ordered_free(void * const ptr)

     {

       pool_type & p = singleton::instance();

       details::pool::guard<Mutex> g(p);

       p.p.ordered_free(ptr);

     }

     static void free(void * const ptr, const size_type n)

     {

       pool_type & p = singleton::instance();

       details::pool::guard<Mutex> g(p);

       p.p.free(ptr, n);

     }

     static void ordered_free(void * const ptr, const size_type n)

     {

       pool_type & p = singleton::instance();

       details::pool::guard<Mutex> g(p);

       p.p.ordered_free(ptr, n);

     }

     static bool release_memory()

     {

       pool_type & p = singleton::instance();

       details::pool::guard<Mutex> g(p);

       return p.p.release_memory();

     }

     static bool purge_memory()

     {

       pool_type & p = singleton::instance();

       details::pool::guard<Mutex> g(p);

       return p.p.purge_memory();

     }

 };

 } // namespace boost

 #endif