PropagatingPolymorphicAllocator.h

Go to the documentation of this file.

#ifndef ZSERIO_PPMR_PROPAGATING_POLYMORPHIC_ALLOCATOR_H_INC
#define ZSERIO_PPMR_PROPAGATING_POLYMORPHIC_ALLOCATOR_H_INC
 
#include <cstddef>
#include <memory_resource>
 
namespace zserio
{
namespace ppmr
{
 
template <class T>
class PropagatingPolymorphicAllocator
{
public:
    using value_type = T;
 
    using propagate_on_container_copy_assignment = std::true_type;
    using propagate_on_container_move_assignment = std::true_type;
    using propagate_on_container_swap = std::true_type;
 
    PropagatingPolymorphicAllocator(
            std::pmr::memory_resource* resource = std::pmr::get_default_resource()) noexcept :
            m_resource(
                    resource != nullptr ? resource : std::pmr::get_default_resource()) // non-standard extension
    {}
 
    ~PropagatingPolymorphicAllocator() = default;
 
    PropagatingPolymorphicAllocator(const PropagatingPolymorphicAllocator& other) noexcept = default;
    PropagatingPolymorphicAllocator& operator=(const PropagatingPolymorphicAllocator& other) noexcept = default;
 
    PropagatingPolymorphicAllocator(PropagatingPolymorphicAllocator&& other) noexcept = default;
    PropagatingPolymorphicAllocator& operator=(PropagatingPolymorphicAllocator&& other) noexcept = default;
    template <class U>
    PropagatingPolymorphicAllocator(const PropagatingPolymorphicAllocator<U>& other) noexcept :
            m_resource(other.resource())
    {}
 
    template <class U>
    PropagatingPolymorphicAllocator& operator=(const PropagatingPolymorphicAllocator<U>& other) noexcept
    {
        m_resource = other.resource();
        return *this;
    }
    value_type* allocate(std::size_t size)
    {
        return static_cast<value_type*>(m_resource->allocate(size * sizeof(value_type), alignof(value_type)));
    }
 
    void deallocate(value_type* memory, std::size_t size) noexcept
    {
        m_resource->deallocate(memory, size * sizeof(value_type), alignof(value_type));
    }
 
    template <typename U, typename... Args>
    void construct(U* ptr, Args&&... args)
    {
        using Self = decltype(*this);
        if constexpr (std::uses_allocator_v<std::remove_cv_t<U>, Self>)
        {
            if constexpr (std::is_constructible_v<U, std::allocator_arg_t, Self, Args...>)
            {
                new (static_cast<void*>(ptr)) U(std::allocator_arg, *this, std::forward<Args>(args)...);
            }
            else
            {
                new (static_cast<void*>(ptr)) U(std::forward<Args>(args)..., *this);
            }
        }
        else
        {
            new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...);
        }
    }
 
    template <typename U>
    void destroy(U* ptr) noexcept(noexcept(ptr->~U()))
    {
        ptr->~U();
    }
 
    PropagatingPolymorphicAllocator select_on_container_copy_construction() const
    {
        return *this;
    }
 
    std::pmr::memory_resource* resource() const noexcept
    {
        return m_resource;
    }
 
private:
    std::pmr::memory_resource* m_resource;
};
 
template <class T, class U>
bool operator==(
        const PropagatingPolymorphicAllocator<T>& lhs, const PropagatingPolymorphicAllocator<U>& rhs) noexcept
{
    return *lhs.resource() == *rhs.resource();
}
 
template <class T, class U>
bool operator!=(
        const PropagatingPolymorphicAllocator<T>& lhs, const PropagatingPolymorphicAllocator<U>& rhs) noexcept
{
    return !(lhs == rhs);
}
 
} // namespace ppmr
} // namespace zserio
 
#endif // ZSERIO_PPMR_PROPAGATING_POLYMORPHIC_ALLOCATOR_H_INC