mn_basic_allocator.hpp

Go to the documentation of this file.

/*
*This file is part of the Mini Thread Library (https://github.com/RoseLeBlood/MiniThread ).
*Copyright (c) 2018 Amber-Sophia Schroeck
*
*The Mini Thread Library is free software; you can redistribute it and/or modify
*it under the terms of the GNU Lesser General Public License as published by
*the Free Software Foundation, version 3, or (at your option) any later version.
 
*The Mini Thread Library is distributed in the hope that it will be useful, but
*WITHOUT ANY WARRANTY; without even the implied warranty of
*MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
*General Public License for more details.
*
*You should have received a copy of the GNU Lesser General Public
*License along with the Mini Thread  Library; if not, see
*<https://www.gnu.org/licenses/>.
*/
#ifndef __MINILIB_BASIC_ALLOCATOR_H__
#define __MINILIB_BASIC_ALLOCATOR_H__
 
#include "../mn_config.hpp"
 
#include "../mn_algorithm.hpp"
#include "../mn_functional.hpp"
#include "../mn_typetraits.hpp"
#include "../utils/mn_alignment.hpp"
 
#include "mn_basic_allocator_maximal_filter.hpp"
 
namespace mn {
    namespace memory {
 
        class basic_allocator_filter {
        public:
            bool on_pre_alloc(size_t size, size_t alignment) { return true; }
            void on_alloc(size_t size, size_t alignment) { }
 
            bool on_pre_dealloc(size_t size, size_t alignment) { return true; }
            void on_dealloc(size_t size, size_t alignment) { }
        };
 
        template <class TAllocator, class TFilter = basic_allocator_filter>
        class basic_allocator  {
        public:
            using allocator_category = typename TAllocator::allocator_category ;
            using is_thread_safe = typename TAllocator::is_thread_safe ;
            using filter_type = TFilter;
 
            using value_type = void;
            using pointer = void*;
            using const_pointer = const void*;
            using difference_type = mn::ptrdiff_t;
            using size_type = size_t;
 
            basic_allocator() noexcept  { TAllocator::first();  }
 
            pointer allocate(size_t size, size_t alignment) {
                pointer _mem = nullptr;
 
                if(m_fFilter.on_pre_alloc(size)) {
                    _mem = TAllocator::allocate(size, alignment);
                    m_fFilter.on_alloc(size);
                }
                return _mem;
            }
 
            pointer allocate(size_t size) {
                return allocate(size, mn::alignment_for(size));
            }
 
            pointer allocate(size_t count, size_t size, size_t alignment = 0) {
                return allocate(count * size, (alignment == 0) ? mn::alignment_for(size) : alignment);
            }
 
 
            void deallocate(pointer address, size_t size, size_t alignment) noexcept {
                if(m_fFilter.on_pre_dealloc(size)) {
                    TAllocator::deallocate(address, size, alignment);
                    m_fFilter.on_dealloc(size);
                }
            }
 
            void deallocate(pointer address, size_t size) noexcept {
                deallocate(address, size, mn::alignment_for(size));
            }
 
            void deallocate(pointer address, size_t count, size_t size, size_t alignment) noexcept {
                size = size * count;
                if(m_fFilter.on_pre_dealloc(size)) {
                    TAllocator::deallocate(address, size, (alignment == 0) ? mn::alignment_for(size) : alignment);
                    m_fFilter.on_dealloc(size);
                }
            }
 
            template <class Type, typename... Args>
            Type* construct(Args&&... args) {
                auto _size = sizeof(Type);
 
                void* _mem = allocate(_size, mn::alignment_for(_size) );
 
                return ::new (_mem) Type(mn::forward<Args>(args)...);
            }
 
            template <class Type>
            void destroy(Type* address) noexcept {
                if(address == nullptr) return;
 
                auto _size = sizeof(Type);
 
                mn::destruct<Type>(address);
                deallocate(address, _size, mn::alignment_for(_size));
            }
 
            size_t get_max_alocator_size() const noexcept {
                return TAllocator::get_max_alocator_size();
            }
 
        private:
            filter_type m_fFilter;
        };
 
 
    }
}
 
#endif // __MINILIB_BASIC_ALLOCATOR_H__