template
<
    class T,
    class ScrubPolicy = ScrubOnDestroy<BasicScrubber>,
    class AllocPolicy = NoSwapHeap,
    class LockPolicy = NoLocking<AllocPolicy>
>
class SecureAllocator
{
public:
    // Common allocator typedefs
    ...

    size_type max_size()
    {
        return getAllocator().max_count(sizeof(T));
    }

    pointer allocate(size_type num, const_pointer hint = 0)
    {
        LockPolicy::Lock lock;
        void* pmem = getAllocator().doAlloc(num * sizeof(T), hint);
        if (!pmem)
        {
            throw std::bad_alloc();
        }
        return static_cast<pointer>(pmem);
    }

    void deallocate(pointer pmem, size_type num)
    {
        LockPolicy::Lock lock;
        getScrubber().onDeallocate(pmem, num * sizeof(T));
        getAllocator().doFree(pmem, num * sizeof(T));
    }

    void construct(pointer pmem, const value_type& val)
    { 
        new(pmem) value_type(val);
    }

    void destroy(pointer pmem)
    {
        pmem->~value_type();
        getScrubber().onDestroy(pmem, sizeof(T));
    }

private:
    AllocPolicy& getAllocator()
    {
        return PolicyHolder<AllocPolicy>::getPolicy();
    }

    ScrubPolicy& getScrubber()
    {
        return PolicyHolder<ScrubPolicy>::getPolicy();
    }
};

template <class Policy>
class PolicyHolder
{
public:
    typedef MutexLocking<Policy*>::VolatileType        PtrType;

    static Policy& getPolicy()
    {
        static PtrType pPol = NULL;
        if (pPol == NULL)
        {
            typename MutexLocking<PolicyHolder<Policy> >::Lock lock;
            if (pPol == NULL)
            {
                pPol = new Policy();
            }
        }
        return *pPol;
    }
};