CriticalAllocator.hpp

#pragma once

#include <memory>
#include <samchon/library/RWMutex.hpp>

namespace samchon
{
namespace library
{
    template <class T>
    class CriticalAllocator
        : public std::allocator<T>
    {
    private:
        typedef std::allocator<T> super;

        RWMutex rw_mutex;

    public:
        using super::super;

        auto getMutex() -> RWMutex&
        {
            return rw_mutex;
        };
        auto getMutex() const -> const RWMutex&
        {
            return rw_mutex;
        };

        /* ---------------------------------------------------------------
            SINGLE ELEMENT'S CONSTRUCTION AND DESTRUCTION
        --------------------------------------------------------------- */
        template<class _U, class... _Args>
        void construct(_U *ptr, _Args&&... args)
        {
            UniqueWriteLock uk(rw_mutex);

            super::construct(ptr, args);
        };

        template<class _U>
        void destroy(_U *ptr)
        {
            UniqueWriteLock uk(rw_mutex);

            super::destroy(ptr);
        };

        /* ---------------------------------------------------------------
            MULTIPLE ELEMENT'S ALLOCATION AND DEALLOCATION
        --------------------------------------------------------------- */
        auto allocate(size_type n, std::allocator<void>::const_pointer hint = NULL) -> pointer
        {
            UniqueWriteLock uk(rw_mutex);

            super::allocate(n, hint);
        };

        void deallocate(pointer ptr, size_type size)
        {
            UniqueWriteLock uk(rw_mutex);

            super::deallocate(ptr, size);
        };
    };
};
};