from_delay_delete.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <concepts>
#include <memory/from_allocator.hpp>
#include <memory>
 
namespace from {
using delay_deleter = void (*)(void*);
 
LIBERAPI void request_delete(delay_deleter deleter, void* p);
 
template <typename T, typename AllocatorTag>
class delay_delete : private from::allocator<T, AllocatorTag> {
    using base_type = from::allocator<T, AllocatorTag>;
 
    const base_type& base() const noexcept {
        return static_cast<const base_type&>(*this);
    }
 
public:
    delay_delete() noexcept : base_type() {}
 
    delay_delete(const delay_delete&) noexcept : base_type() {}
 
    delay_delete(delay_delete&&) noexcept : base_type() {}
 
    template <typename U>
        requires std::convertible_to<U*, T*>
    delay_delete(const delay_delete<U, AllocatorTag>&) noexcept : base_type() {}
 
    template <typename U>
        requires std::convertible_to<U*, T*>
    delay_delete(delay_delete<U, AllocatorTag>&&) noexcept : base_type() {}
 
    delay_delete& operator=(const delay_delete&) noexcept {
        return *this;
    }
 
    template <typename U>
        requires std::convertible_to<U*, T*>
    delay_delete& operator=(const delay_delete<U, AllocatorTag>&) noexcept {
        return *this;
    }
 
    delay_delete& operator=(delay_delete&&) noexcept {
        return *this;
    }
 
    template <typename U>
        requires std::convertible_to<U*, T*>
    delay_delete& operator=(delay_delete<U, AllocatorTag>&&) noexcept {
        return *this;
    }
 
    void operator()(T* p) const noexcept {
        request_delete(
            [](void* p) {
                base_type proxy_allocator;
                std::allocator_traits<base_type>::destroy(proxy_allocator,
                    reinterpret_cast<T*>(p));
                proxy_allocator.deallocate(reinterpret_cast<T*>(p), 1);
            },
            p);
    }
};
 
// TODO: implement
template <typename T, typename AllocatorTag>
class delay_delete<T[], AllocatorTag> {};
} // namespace from