/*

The pool allocator is not being used properly, somehow, with std::list.
When you go to purge the pool, it says nothing was purged, because nothing is even registered as being allocated in the pool.
What is going on here?
I have included copious debugging information. I've even provided a dummy modification of the boost::pool_allocator class to show what's going on.
It's weird. If you change l_type to an std::vector, everything will work, and the output will be: purged? 1

This program outputs the following when l_type is std::list,

debug_pool_allocator<Tag, T, UserAllocator, Mutex, NextSize>::debug_pool_allocator() [with Tag = foo_tag, T = int, UserAllocator = boost::default_user_allocator_new_delete, Mutex = boost::details::pool::default_mutex, unsigned int NextSize = 32u]
debug_pool_allocator<Tag, T, UserAllocator, Mutex, NextSize>::debug_pool_allocator(const debug_pool_allocator<Tag, U, UserAllocator, Mutex, NextSize>&) [with U = int, Tag = foo_tag, T = std::_List_node<int>, UserAllocator = boost::default_user_allocator_new_delete, Mutex = boost::details::pool::default_mutex, unsigned int NextSize = 32u]
static T* debug_pool_allocator<Tag, T, UserAllocator, Mutex, NextSize>::allocate(typename boost::pool<UserAllocator>::size_type) [with Tag = foo_tag, T = std::_List_node<int>, UserAllocator = boost::default_user_allocator_new_delete, Mutex = boost::details::pool::default_mutex, unsigned int NextSize = 32u]
---
static T* debug_pool_allocator<Tag, T, UserAllocator, Mutex, NextSize>::allocate(typename boost::pool<UserAllocator>::size_type) [with Tag = foo_tag, T = std::_List_node<int>, UserAllocator = boost::default_user_allocator_new_delete, Mutex = boost::details::pool::default_mutex, unsigned int NextSize = 32u]
---
...
purged? 0
released? 0

This program outputs the following when l_type is std::vector,

debug_pool_allocator<Tag, T, UserAllocator, Mutex, NextSize>::debug_pool_allocator() [with Tag = foo_tag, T = int, UserAllocator = boost::default_user_allocator_new_delete, Mutex = boost::details::pool::default_mutex, unsigned int NextSize = 32u]
static T* debug_pool_allocator<Tag, T, UserAllocator, Mutex, NextSize>::allocate(typename boost::pool<UserAllocator>::size_type) [with Tag = foo_tag, T = int, UserAllocator = boost::default_user_allocator_new_delete, Mutex = boost::details::pool::default_mutex, unsigned int NextSize = 32u]
---
static T* debug_pool_allocator<Tag, T, UserAllocator, Mutex, NextSize>::allocate(typename boost::pool<UserAllocator>::size_type) [with Tag = foo_tag, T = int, UserAllocator = boost::default_user_allocator_new_delete, Mutex = boost::details::pool::default_mutex, unsigned int NextSize = 32u]
static void debug_pool_allocator<Tag, T, UserAllocator, Mutex, NextSize>::deallocate(T*, typename boost::pool<UserAllocator>::size_type) [with Tag = foo_tag, T = int, UserAllocator = boost::default_user_allocator_new_delete, Mutex = boost::details::pool::default_mutex, unsigned int NextSize = 32u]
---
...
purged? 1
released? 0

*/

#include <iostream>
using std::cout;
using std::endl;
#include <list>
#include <vector>
#include <boost/current_function.hpp>
#include <boost/limits.hpp>
// std::numeric_limits
#include <new>
// std::bad_alloc
#include <boost/pool/poolfwd.hpp>
#include <boost/pool/singleton_pool.hpp>
#include <boost/pool/pool_alloc.hpp>

#define DEBUG_FUNC cout << BOOST_CURRENT_FUNCTION << " " << endl

template <
    class Tag,
    class T,
    class UserAllocator = boost::default_user_allocator_new_delete,
    class Mutex = boost::details::pool::default_mutex,
    unsigned NextSize = 32
>
class debug_pool_allocator
{
public:

    typedef T value_type;
    typedef UserAllocator user_allocator;
    typedef Mutex mutex;
    static unsigned const next_size = NextSize;

    typedef value_type* pointer;
    typedef value_type const* const_pointer;
    typedef value_type& reference;
    typedef value_type const& const_reference;
    typedef typename boost::pool<UserAllocator>::size_type size_type;
    typedef typename boost::pool<UserAllocator>::difference_type difference_type;

    template <class U>
    struct rebind {
        typedef debug_pool_allocator<Tag, U, UserAllocator, Mutex, NextSize> other;
    };

    debug_pool_allocator() {
        DEBUG_FUNC;
    }

    // default copy constructor

    // default assignment operator

    // not explicit, mimicking std::allocator [20.4.1]
    template <class U>
    debug_pool_allocator(
        debug_pool_allocator<Tag, U, UserAllocator, Mutex, NextSize> const&
    ) {
        DEBUG_FUNC;
    }

    // default destructor

    static pointer address(reference r) {
        DEBUG_FUNC;
        return &r;
    }

    static const_pointer address(const_reference s) {
        DEBUG_FUNC;
        return &s;
    }

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

    static void construct(pointer const ptr, value_type const& t) {
        DEBUG_FUNC;
        new(ptr) T(t);
    }

    static void destroy(pointer const ptr) {
        DEBUG_FUNC;
        ptr->~T();
    }

    bool operator==(debug_pool_allocator const&) const {
        DEBUG_FUNC;
        return true;
    }

    bool operator!=(debug_pool_allocator const&) const {
        DEBUG_FUNC;
        return false;
    }

    static pointer allocate(size_type const n) {
        DEBUG_FUNC;
        const pointer ret =
            static_cast<pointer>(
                boost::singleton_pool<
                    Tag, sizeof(T), UserAllocator, Mutex, NextSize
                >::ordered_malloc(n)
            )
        ;

        if (ret == 0)
            throw std::bad_alloc();

        return ret;
    }

    static pointer allocate(size_type const n, void const* const) {
        DEBUG_FUNC;
        return allocate(n);
    }

    static void deallocate(pointer const ptr, size_type const n) {
        DEBUG_FUNC;
        boost::singleton_pool<
            Tag, sizeof(T), UserAllocator, Mutex, NextSize
        >::ordered_free(ptr, n);
    }
};

// ---

struct foo_tag {};
// IF YOU CHANGE THIS TO std::vector, IT WILL DEALLOCATE PROPERLY!
typedef std::list<
    int,
    debug_pool_allocator<foo_tag, int>
> l_type;

int main()
{
    bool success = false;

    l_type* l = new l_type;
    for (int i=0; i<2; ++i) {
        l->push_back(444);
        cout << "---" << endl;
    }

    cout << "..." << endl;

    success = boost::singleton_pool<foo_tag, sizeof(int)>::purge_memory();
    cout << "purged? " << success << endl;

    success = boost::singleton_pool<foo_tag, sizeof(int)>::release_memory();
    cout << "released? " << success << endl;
}